常連

注目の的

社会貢献

質問力

現在、「U-NetでPascal VOC 2012の画像をSemantic Segmentationする (TensorFlow)」モデルをベースにして製品の欠陥検出しようとしています。
その上記モデルをVOC 2012の画像を使って学習させたら、250epoch終了して、かなりLossを小さくすることができました。従いまして、トレーニングは成功だと思います。
しかし、そのモデルを用いてセグメンテーション結果の画像を出力する方法がわかりません。
そのソースの中にそのプログラムがあるのでしょうか。それともsaver = tf.train.Saverを使って重みを出力する必要があるのでしょうか。
知見のある方、よろしくお願いします。

【サイト】
https://qiita.com/tktktks10/items/0f551aea27d2f62ef708

【ソース】
https://github.com/tks10/segmentation_unet

【参考（学習結果）】
Epoch: 248
[Train] Loss: 0.059211913  Accuracy: 0.9756693
[Test]  Loss: 2.6319973 Accuracy: 0.7496191
Epoch: 249
[Train] Loss: 0.057428934  Accuracy: 0.9761983
[Test]  Loss: 2.6868184 Accuracy: 0.74921834
Result
[Test]  Loss: 2.6868184 Accuracy: 0.74921834

Semantic Segmentationで重みをsaveしてセグメンテーション結果の画像を出力したい

### わからないこと
最近勉強を始めたプログラミング初心者です。
pythonで派生クラスを作る際、基底クラスにobjectクラスを継承する必要があるのでしょうか？またそれはなぜでしょうか？
(下の例でclass Parent(object)のobjectを指しています。)


今持っている教科書ではそもそもobjectを継承していなく、サイトで調べた際継承していました。
objectクラスを調べたところpythonの基本的な関数とかが入っているとありそれなら今回に限らずクラスを作る全ての時にobjectクラスを継承するべきでは？となり混乱しています。

素人質問で申し訳ありませんがよろしくお願い致します。

```
class Parent(object): # object型を継承
  def __init__(self, child_num):
    self._parent_num = 5
    self._child_num = child_num

  def calc(self):
    result = (self._parente_num + self._child_num) * 2
    return result

class Child_A(Parent):
  def __init__(self):
    super().__init__(3)

class Child_B(Parent):
  def __init__(self):
    super().__init__(4)
```

クラス継承でobjectクラスを継承する理由

### PCLを利用し、velodyneのスキャンデータを連続的に保存する
https://teratail.com/questions/input#
ubuntu16.04でPCL1.8の関数である"savePCDFilBinary"を利用し、velodyneのスキャンデータをひとつのファイルに連続的に保存したいと考えています。
上記のPCLの関数では１スキャン分を保存してくれますが、次のスキャンデータを同じファイルの末尾に追加することができません。
同じファイルの末尾に保存する方法についてご指導ください。また、別な方法で容量を抑え、連続的に保存する方法などあれば教えていただきたいです。


### savePCDFileBinary


```C++
//savePCDFileの中身
inline int 
    savePCDFile (const std::string &file_name, const pcl::PCLPointCloud2 &cloud,
                 const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
                 const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
                 const bool binary_mode = false)
    {
      PCDWriter w;
      return (w.write (file_name, cloud, origin, orientation, binary_mode));
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename PointT> int
pcl::PCDWriter::writeBinary (const std::string &file_name, 
                             const pcl::PointCloud<PointT> &cloud, 
                             const std::vector<int> &indices)
{
  if (cloud.points.empty () || indices.empty ())
  {
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Input point cloud has no data or empty indices given!");
    return (-1);
  }
  int data_idx = 0;
  std::ostringstream oss;
  oss << generateHeader<PointT> (cloud, static_cast<int> (indices.size ())) << "DATA binary\n";
  oss.flush ();
  data_idx = static_cast<int> (oss.tellp ());

#if _WIN32
  HANDLE h_native_file = CreateFileA (file_name.c_str (), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  if (h_native_file == INVALID_HANDLE_VALUE)
  {
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Error during CreateFile!");
    return (-1);
  }
#else

  int fd = pcl_open (file_name.c_str (), O_RDWR | O_CREAT | O_TRUNC, static_cast<mode_t> (0600));
  if (fd < 0)
  {
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Error during open!");
    return (-1);
  }
#endif
  // Mandatory lock file
  boost::interprocess::file_lock file_lock;
  setLockingPermissions (file_name, file_lock);

  std::vector<pcl::PCLPointField> fields;
  std::vector<int> fields_sizes;
  size_t fsize = 0;
  size_t data_size = 0;
  size_t nri = 0;
  pcl::getFields (cloud, fields);
  // Compute the total size of the fields
  for (size_t i = 0; i < fields.size (); ++i)
  {
    if (fields[i].name == "_")
      continue;
    
    int fs = fields[i].count * getFieldSize (fields[i].datatype);
    fsize += fs;
    fields_sizes.push_back (fs);
    fields[nri++] = fields[i];
  }
  fields.resize (nri);
  
  data_size = indices.size () * fsize;

  // Prepare the map
#if _WIN32
  HANDLE fm = CreateFileMapping (h_native_file, NULL, PAGE_READWRITE, 0, data_idx + data_size, NULL);
  char *map = static_cast<char*>(MapViewOfFile (fm, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, data_idx + data_size));
  CloseHandle (fm);

#else
  // Stretch the file size to the size of the data
  off_t result = pcl_lseek (fd, getpagesize () + data_size - 1, SEEK_SET);
  if (result < 0)
  {
    pcl_close (fd);
    resetLockingPermissions (file_name, file_lock);
    PCL_ERROR ("[pcl::PCDWriter::writeBinary] lseek errno: %d strerror: %s\n", errno, strerror (errno));
    
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Error during lseek ()!");
    return (-1);
  }
  // Write a bogus entry so that the new file size comes in effect
  result = static_cast<int> (::write (fd, "", 1));
  if (result != 1)
  {
    pcl_close (fd);
    resetLockingPermissions (file_name, file_lock);
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Error during write ()!");
    return (-1);
  }

  char *map = static_cast<char*> (mmap (0, data_idx + data_size, PROT_WRITE, MAP_SHARED, fd, 0));
  if (map == reinterpret_cast<char*> (-1)) //MAP_FAILED)
  {
    pcl_close (fd);
    resetLockingPermissions (file_name, file_lock);
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Error during mmap ()!");
    return (-1);
  }
#endif

  // Copy the header
  memcpy (&map[0], oss.str ().c_str (), data_idx);

  char *out = &map[0] + data_idx;
  // Copy the data
  for (size_t i = 0; i < indices.size (); ++i)
  {
    int nrj = 0;
    for (size_t j = 0; j < fields.size (); ++j)
    {
      memcpy (out, reinterpret_cast<const char*> (&cloud.points[indices[i]]) + fields[j].offset, fields_sizes[nrj]);
      out += fields_sizes[nrj++];
    }
  }

#if !_WIN32
  // If the user set the synchronization flag on, call msync
  if (map_synchronization_)
    msync (map, data_idx + data_size, MS_SYNC);
#endif

  // Unmap the pages of memory
#if _WIN32
    UnmapViewOfFile (map);
#else
  if (munmap (map, (data_idx + data_size)) == -1)
  {
    pcl_close (fd);
    resetLockingPermissions (file_name, file_lock);
    throw pcl::IOException ("[pcl::PCDWriter::writeBinary] Error during munmap ()!");
    return (-1);
  }
#endif
  // Close file
#if _WIN32
  CloseHandle(h_native_file);
#else
  pcl_close (fd);
#endif
  
  resetLockingPermissions (file_name, file_lock);
  return (0);
}
```

### 試したこと

r+ の状態になれば良いと考え、
O_TRUNC　-> O_APPEND
に変更したが、上書きはされず。

### 補足情報（FW/ツールのバージョンなど）

特になし

PCLを利用しvelodyneの３次元点群を連続で保存したい

C++で慣れないと冗長になる`STD::`を省略するおまじないとして覚えた`using namespace std;`ですが、
どこかで使わないほうが良いと見たことがありそれ以降意識して`using namespace std;`を使わないようにしていました。
うろ覚えなので何故使わないほうが良いと思ったのかの理由も忘れてしまっているので再確認したいと思いました。

ネットで検索したコードなどでは`using namespace std;`を使っているケースが思ったよりも多いので迷っています。
個人的にはvectorの2次元配列などをよく使うので長ったらしいなとは思っていました。

使う環境や制限や個人で使ってる分には好みでどちらでも良いなどの回答になると思いますが後学の為に
「一般的にはどういう扱い」なのか、
「そんなの実務では使わないのが常識だよ」などの温度感が知りたいなと思いました。

**※漠然とした質問で恐縮ですがご意見やアドバイスをお聞かせください。**

`using namespace std;`あり
```C++
#include <bits/stdc++.h>
#define rep(i, m, n) for (int i = m; i < n; ++i)

using namespace std;

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  unsigned N, M;
  vector<vector<unsigned>> vec(N, vector<unsigned>(M, 0));
  cin >> N >> M;
  rep(i, 0, N) {
    rep(j, 0, N) { cin >> vec[i][j]; }
  }

  getchar();
  return 0;
}
```

`using namespace std;`なし
```C++
#include <bits/stdc++.h>
#define rep(i, m, n) for (int i = m; i < n; ++i)

int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);

  unsigned N, M;
  std::vector<std::vector<unsigned>> vec(N, std::vector<unsigned>(M, 0));
  std::cin >> N >> M;
  rep(i, 0, N) {
    rep(j, 0, N) {
      std::cin >> vec[i][j];
    }
  }

  getchar();
  return 0;
}
```

C++ 素朴な疑問　using namespace std;　は使わないほうが良い？

### 前提・実現したいこと

GUIでの画像処理ツールの開発

### 発生している問題・エラーメッセージ

今現在は、CUI（C++）上で画像処理プログラムを作成いたしました。
内容はimage.cppを動かすと監視対象のフォルダに画像が入ってきた瞬間に
処理を行い、入力画像windowと処理結果windowが並んで表示されます。
それを、Qtを用いてボタンを押すことで処理が行われ（プログラムが起動）、処理結果がQtのGraphics Viewなどに表示したいと考えています。

困っていることは外部のプログラム（image.cpp）をQProcessを使うことで可能ということは調べたのですが、うまく行きません。
ここを勉強すると良いなどのQtを使ったことがある人のアドバイスがほしいです。
このような処理はQtで書きなおしたほうが良いのでしょうか？
できれば作成したCUIを利用したいと考えています。

###ここに言語名を入力

C++


### 補足情報（FW/ツールのバージョンなど）
ubuntu 16.04LTS
Qt　5.11

画像処理 ツール開発

ディープラーニングの勉強をしています。

なぜシグモイド関数では多クラス分類できず、ソフトマックス関数では多クラス分類できるのでしょうか？
シグモイド関数は０〜１の間で出力を表現し、もっとも大きい出力値を持つのをそのクラスに属する、と分類できそうな気がしていて、多クラス分類にはソフトマックス関数のみが使われている理由を知りたいです。

なぜシグモイド関数では多クラス分類できず、ソフトマックス関数では多クラス分類できるのか？

### 前提・実現したいこと

機械学習初心者で勉強がてらkerasによる分類問題の実装を試みています。
自前のデータを準備し以下のサイトのコード(fruit.py)利用し、2クラスの分類の実装に成功しました。

https://qiita.com/hiroeorz@github/items/ecb39ed4042ebdc0a957

私の目的は多クラス分類だったため、3クラスへの分類を試みたのですが、エラーばかりでうまくできませんでした。
最後のdenseを2から3に変更してみたりと、初心者なりにいじったのですがうまくできませんでした。
先ほどの2クラスに分類するコードを3クラスに分類にするコードに変換したものを頂けないでしょうか？また、それ以上のクラスに分類できるコードに変換する際にも、どこを変更すれば良いのかを教えていただきたいです。
初歩的な質問かもしれませんが、よろしくお願いします。jupyterを使用しています。


### 該当のソースコード

```
from keras.models import Sequential
from keras.layers import Activation, Dense, Dropout
from keras.utils.np_utils import to_categorical
from keras.optimizers import Adagrad
from keras.optimizers import Adam
import numpy as np
from PIL import Image
import os

# 学習用のデータを作る.
image_list = []
label_list = []

# ./data/train 以下のorange,appleディレクトリ以下の画像を読み込む。
for dir in os.listdir("data/train"):
    if dir == ".DS_Store":
        continue

    dir1 = "data/train/" + dir 
    label = 0

    if dir == "apple":    # appleはラベル0
        label = 0
    elif dir == "orange": # orangeはラベル1
        label = 1

    for file in os.listdir(dir1):
        if file != ".DS_Store":
            # 配列label_listに正解ラベルを追加(りんご:0 オレンジ:1)
            label_list.append(label)
            filepath = dir1 + "/" + file
            # 画像を25x25pixelに変換し、1要素が[R,G,B]3要素を含む配列の25x25の２次元配列として読み込む。
            # [R,G,B]はそれぞれが0-255の配列。
            image = np.array(Image.open(filepath).resize((25, 25)))
            print(filepath)
            # 配列を変換し、[[Redの配列],[Greenの配列],[Blueの配列]] のような形にする。
            image = image.transpose(2, 0, 1)
            # さらにフラットな1次元配列に変換。最初の1/3はRed、次がGreenの、最後がBlueの要素がフラットに並ぶ。
            image = image.reshape(1, image.shape[0] * image.shape[1] * image.shape[2]).astype("float32")[0]
            # 出来上がった配列をimage_listに追加。
            image_list.append(image / 255.)

# kerasに渡すためにnumpy配列に変換。
image_list = np.array(image_list)

# ラベルの配列を1と0からなるラベル配列に変更
# 0 -> [1,0], 1 -> [0,1] という感じ。
Y = to_categorical(label_list)

# モデルを生成してニューラルネットを構築
model = Sequential()
model.add(Dense(200, input_dim=1875))
model.add(Activation("relu"))
model.add(Dropout(0.2))

model.add(Dense(200))
model.add(Activation("relu"))
model.add(Dropout(0.2))

model.add(Dense(2))
model.add(Activation("softmax"))

# オプティマイザにAdamを使用
opt = Adam(lr=0.001)
# モデルをコンパイル
model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])
# 学習を実行。10%はテストに使用。
model.fit(image_list, Y, nb_epoch=1500, batch_size=100, validation_split=0.1)

# テスト用ディレクトリ(./data/train/)の画像でチェック。正解率を表示する。
total = 0.
ok_count = 0.

for dir in os.listdir("data/train"):
    if dir == ".DS_Store":
        continue

    dir1 = "data/test/" + dir 
    label = 0

    if dir == "apple":
        label = 0
    elif dir == "orange":
        label = 1

    for file in os.listdir(dir1):
        if file != ".DS_Store":
            label_list.append(label)
            filepath = dir1 + "/" + file
            image = np.array(Image.open(filepath).resize((25, 25)))
            print(filepath)
            image = image.transpose(2, 0, 1)
            image = image.reshape(1, image.shape[0] * image.shape[1] * image.shape[2]).astype("float32")[0]
            result = model.predict_classes(np.array([image / 255.]))
            print("label:", label, "result:", result[0])

            total += 1.

            if label == result[0]:
                ok_count += 1.

print("seikai: ", ok_count / total * 100, "%")
```


### 補足情報（FW/ツールのバージョンなど）

window 10
python 3.6.6
jupyter notebook

kerasによる2クラス分類から3クラス分類への変更

C++前提で話します。

static修飾子がありますが、classを使っていてstaticが必要だと思ったことがありません。
staticでできることは理解していますがやはり使う機会はありません。
そもそもオブジェクト指向的にstaticって矛盾していませんか？
オブジェクト指向を完全に理解しているわけではないので全く見当違いなことを言っていたら申し訳ないです。
もしオブジェクト指向的におかしくないのなら、どのような場面でstaticは便利なのでしょうか？




追記

staticが必要になってくるというのは分かりました。
では、積極的にstaticにした方が良いのでしょうか？
そこまで複雑なコードを書いてきていないからかもしれませんが、staticにしても問題ないという変数や関数に遭遇していません（遭遇しているが気づいていないかもしれませんが）。どうしてもstaticに違和感があります。

C++ オブジェクト指向 staticの使用について

GLFWライブラリを介してOpenGLを使用しているのですが、
OpenGLの動きに関連してCPUとGPUのどちらがどのタイミングで使われているかを知りたいです。

現在私はウィンドウを作成し、シェーダープログラムを実行する環境を整えたところまでしかわかりません。(図形描画を実際に行なっていないということです。)

その上で質問ですが、

1. GLFW(OpenGL)にてCPU, GLSLにてGPUを司っているのか？
少し語弊があるかと思いますが、ウィンドウ作成やダブルバッファリングのバッファ入れ替えをCPUで司り、シェーダー等をGPUで処理しているのかということです。

2. また、もし1.が正しかった場合、ダブルバッファリングのバッファ入れ替えと各バッファへの描画をそれぞれCPUとGPUで分けているからこそスムーズな処理が可能であり、CPUの他にGPUを必要としている理由なのか？

まだ始めたばかりなので自分の中でだいぶフワフワしています。
この質問である程度はっきりさせておきたいです。

回答お願いします。( ͡° ͜ʖ ͡°)

OpenGLにおけるCPUとGPUの動作の違いについて

### 前提・実現したいこと

ここに質問の内容を詳しく書いてください。
センサーから得られた文字列の外部データの値を読み込んでプロットしようとしています。
そのデータをフーリエ変換することで、周波数成分を可視化したいのですが、エラーが出てしまいました。

どのようにしたらこのwarningを解消して、周波数成分を可視化することができるでしょうか。
初歩的な質問かもしれませんが、よろしくお願いいたします。

i am trying a Matlab code in Python
i want to see FREQUENCY COMPONENT. 
so i try to plot by reading data and do Fourier　trans form.
but my code gives a warning 

### 発生している問題・エラーメッセージ

```
C:\Users******\Anaconda3\lib\site-packages\numpy\core\numeric.py:492: ComplexWarning: Casting complex values to real discards the imaginary part
  return array(a, dtype, copy=False, order=order)

```

### 該当のソースコード

```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

if __name__ == '__main__':
    df = pd.read_csv("sleep.csv", names=('time','values','-400'))

    x = df["time"]
    y = df["-400"]
    z = df["values"]

    f = np.fft.fft(y)
    f_abs = np.abs(f)
    print(f_abs)

    plt.subplot(211)
    plt.plot(y)

    plt.subplot(212)
    plt.plot(f_abs)

    plt.show()
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）
人物の転倒検出のために、
横になっている、座っている、転倒するなどの区別をできるような
周波数成分を知りたいです。

外部データをFourier変換することで周波数成分を可視化したい

学習の様子を可視化できないです。
```ここに言語を入力
・
・
・
# placeholders
input_sequence = Input((story_maxlen,))
question = Input((query_maxlen,))

# encoders
# embed the input sequence into a sequence of vectors
input_encoder_m = Sequential()
input_encoder_m.add(Embedding(input_dim=vocab_size,
                              output_dim=64))
input_encoder_m.add(Dropout(0.3))
# output: (samples, story_maxlen, embedding_dim)

# embed the input into a sequence of vectors of size query_maxlen
input_encoder_c = Sequential()
input_encoder_c.add(Embedding(input_dim=vocab_size,
                              output_dim=query_maxlen))
input_encoder_c.add(Dropout(0.3))
# output: (samples, story_maxlen, query_maxlen)

# embed the question into a sequence of vectors
question_encoder = Sequential()
question_encoder.add(Embedding(input_dim=vocab_size,
                               output_dim=64,
                               input_length=query_maxlen))
question_encoder.add(Dropout(0.3))
# output: (samples, query_maxlen, embedding_dim)

# encode input sequence and questions (which are indices)
# to sequences of dense vectors
input_encoded_m = input_encoder_m(input_sequence)
input_encoded_c = input_encoder_c(input_sequence)
question_encoded = question_encoder(question)

# compute a 'match' between the first input vector sequence
# and the question vector sequence
# shape: `(samples, story_maxlen, query_maxlen)`
match = dot([input_encoded_m, question_encoded], axes=(2, 2))
match = Activation('softmax')(match)

# add the match matrix with the second input vector sequence
response = add([match, input_encoded_c])  # (samples, story_maxlen, query_maxlen)
response = Permute((2, 1))(response)  # (samples, query_maxlen, story_maxlen)

# concatenate the match matrix with the question vector sequence
answer = concatenate([response, question_encoded])

# the original paper uses a matrix multiplication for this reduction step.
# we choose to use a RNN instead.
answer = LSTM(32)(answer)  # (samples, 32)

# one regularization layer -- more would probably be needed.
answer = Dropout(0.3)(answer)
answer = Dense(vocab_size)(answer)  # (samples, vocab_size)
# we output a probability distribution over the vocabulary
answer = Activation('softmax')(answer)

# build the final model
model = Model([input_sequence, question], answer)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy',
              metrics=['accuracy'])

# train
hist = model.fit([inputs_train, queries_train], answers_train,
          batch_size=32,
          epochs=120,
          validation_data=([inputs_test, queries_test], answers_test))


model_path1 = 'model1.h5'
model.save(model_path1)

val_acc = hist.history['val_acc']

plt.rc('font',family='serif')
fig = plt.figure()
plt.plot(range(240),val_acc,label='acc',color='black')
plt.xlabel('epochs')
plt.show()

```
のようにコードを書いて学習の様子を可視化しようとしました。
しかし、何エポックになってもy軸が０のところにずっと線が引かれており学習の様子を可視化できませんでした。学習自体はできており、可視化がだけがうまくいっていないです。なぜうまく行かないのでしょうか？

学習の様子を可視化できない

### 前提・実現したいこと

ボタンを押すとそれぞれのファイル内の画像を一覧表示させるシステムを製作したいです。
ボタンを作る方法や紐づける方法はわかっているのですが、画像ファイルをunity内に持ってくる方法がわかりません。

### 発生している問題・エラーメッセージ

```
エラーメッセージ
```

### 該当のソースコード

```ここに言語名を入力
ソースコード
```

### 試したこと
・imageを使用して画像表示
・空のgame object、スクリプト内にファイルを組み込めるかどうか
→既に存在している画像を一覧表示させることまでできました。ただ、プログラムを組んだ後に撮影することで更新される画像の一覧表示方法がわかりません。

### 補足情報（FW/ツールのバージョンなど）


拙い日本語で申し訳ありませんがもしよろしければよろしくお願い致します。

unityで画像ファイルを一覧表示させたい

現在Tensorflowをバックエンドとしたkerasでネットワークを組んでいます。

ネットワークの途中で例えば(None, 10, 10, 1)の様な出力があったとします。ここで、この出力はテンソルになっていると思います。

そこで質問したいのですが、この出力テンソルを一度numpyに変換して、ある処理をした後に再びテンソルに戻してネットワークに情報を流したいです。

そこで質問なのですが、ネットワークの途中で出力のテンソルをnumpyに変換する方法と、numpyをテンソルに変換する方法が知りたいです。

現在はここを見ていますが、分かりません。

https://github.com/tensorflow/tensorflow/blob/r1.10/tensorflow/python/keras/backend.py

よろしくお願いします。

kerasで途中のテンソルをnumpy化

主成分分析の次元削減に関して学習しています
そこで分からないことがあるので質問させてください

※scikit-learnのPCAを使ってコードを書いています

①特徴量が30個あるデータを2つの主成分だけ維持するとした場合
この2つというのは30個ある特徴量のなかで1番分散が大きい特徴量、2番目に分散が大きい特徴量を維持する
という認識はあっているでしょうか？

②以下のように主成分を見れるコードを作成したのですが、2つの主成分に対して30個の特徴量を指しているのかなと考えるのですが
ここで表示されている30個の値は何を示しているのでしょうか？
また、2つの主成分とされているものはどの特徴量を指している、というのはどう判断するのでしょうか（そもそも①の理解が間違っているかもしれません）

理解が出来ておらず的外れな質問をしていると思いますがアドバイス宜しくお願い致します。

```python
print('PCA components shape : {}'.format(pca.components_.shape))
#PCA components shape : (2, 30)

print('PCA components : \n {}'.format(pca.components_))

#PCA components : 
 [[ 0.21890244  0.10372458  0.22753729  0.22099499  0.14258969  0.23928535
   0.25840048  0.26085376  0.13816696  0.06436335  0.20597878  0.01742803
   0.21132592  0.20286964  0.01453145  0.17039345  0.15358979  0.1834174
   0.04249842  0.10256832  0.22799663  0.10446933  0.23663968  0.22487053
   0.12795256  0.21009588  0.22876753  0.25088597  0.12290456  0.13178394]
 [-0.23385713 -0.05970609 -0.21518136 -0.23107671  0.18611302  0.15189161
   0.06016536 -0.0347675   0.19034877  0.36657547 -0.10555215  0.08997968
  -0.08945723 -0.15229263  0.20443045  0.2327159   0.19720728  0.13032156
   0.183848    0.28009203 -0.21986638 -0.0454673  -0.19987843 -0.21935186
   0.17230435  0.14359317  0.09796411 -0.00825724  0.14188335  0.27533947]]
```

python 主成分分析（PCA）について

#問題点
オブジェクトファイルをインポートすると，初期値の原点より大きくずれたところに表示されてしまいます。

![インポート時の表示画面](8b06320eedb930ea585178e7ed417aac.png)

#試したこと
ショートカットキーの"c", "."を試してみましたが，解決できませんでした

ジオメトリを原点に移動，原点をジオメトリに移動を用いず（原点の情報は変更せず）に，画面の中心にオブジェクトを表示する方法を教えてください。
ショートカットキーがあったように思うのですが，久しぶりにBlenderを開いたため，全く思い出せません…
初歩的内容すぎてお恥ずかしいのですが，よろしくお願いいたします。

【Blender】オブジェクトを画面の中心に持ってくる方法

### 前提・実現したいこと
![イメージ説明](177dc44f254e68fc1c5bbba1b9f36fcd.png)
上記の画像に対して、OpenCVのfindcontours関数を用いて輪郭検出(出力:contours=12)となるようなプログラムを作成したいです。
斜め線の太さが2ドット以上あれば、望んだ結果が得られるのですが、今回の例では斜め線の太さが1ドットしかなく、findcontoursではうまく検出できないようです。

線の太さは1ドットのままで、輪郭を検出できるような方法があれば教えて頂きたいです。
もし無ければ、代替案も教えて頂けると幸いです。

### 該当のソースコード

import matplotlib.pyplot as plt
import cv2
import numpy as np
%matplotlib inline

import sys
import math

img = cv2.imread('sen.png')
img2 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.imshow(img2,cmap='gray')
plt.show()

image, contours, hierarchy=cv2.findContours(img2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
print("{} contours.".format(len(contours)))
print("{} hierarchy.".format(len(hierarchy)))

OpenCVの輪郭検出関数(findcontours)における1ドット斜め線の検出について

以下のようなテキストファイルにおいて、3行目から6行目の数値を2次元配列としてNumpyの配列に格納したいと考えています。配列の縦と横の大きさはわかっています。

`numpy.loadtxt`の`skiprows`オプションでは最初の方しかスキップできませんし、`numpy.fromfile`もうまく活用できそうにありませんでした。

テキストファイル上の任意の位置にある数値をNumpyの配列に格納したいと考えております。
アドバイス等、ご教示をお願いいたします。

```File
2 4
9 6
-1 3 4 5 9 0
3 2 13 34 2 7
2 4 1 0 8 23
4 5 1 19 49 54
1 5
3 9
3 2
```

ファイルからnumpy配列に読み出したい

○質問
Pythonに関する質問です。
spyderでGUI作成をしようとしたところ、下記のエラーが出ました。
一方、Jupyter Notebookでは問題なく実行できました。
この違いは、何が原因でしょうか？

○エラーメッセージ
terminating with uncaught exception of type NSException

○コード
import tkinter

root = tkinter.Tk()
root.title("Window title")
root.geometry("400x300+1000+10")
root.mainloop()

○バージョン
Python 3.6.5
tkinter 8.6

PythonのGUI作成時エラー

C#のProcessを利用して，pythonファイルを実行しています．

pythonファイルを実行する際に，引数としてjsonファイルを渡すと，標準出力に結果が表示されます．
（コマンドプロンプトで直接叩くと正常に動くpyhonファイルです）

下記のコードで実行しているのですが，jsonファイルを渡せていないようです．

(1)"< sample.json"の部分を，どのようにProcessで渡せばよろしいのでしょうか．

(2)"> result.json"で，結果をjsonファイルで保存する場合には，どのように指定すればよろしいのでしょうか．

恐れ入りますが，アドバイスを頂けますと幸いです．

(1)
```C#
var process = new Process();
            
process.StartInfo.FileName = @"C:\Users\user\python.exe";
            
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardInput = false;
process.StartInfo.CreateNoWindow = true;

process.StartInfo.Arguments = @"C:\Users\user\test.py < sample.json";

process.Start();

string results = process.StandardOutput.ReadToEnd();

process.WaitForExit();
process.Close();
```

(2)
```C#
var process = new Process();
            
process.StartInfo.FileName = @"C:\Users\user\python.exe";
            
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardInput = false;
process.StartInfo.CreateNoWindow = true;

process.StartInfo.Arguments = @"C:\Users\user\test.py < sample.json > result.json";

process.Start();
process.WaitForExit();
process.Close();
```

C#でpythonファイルを実行する際に，引数としてファイルを渡し，結果をファイルに保存する方法

unityのテラインで作った地面にテクスチャを貼りたいのですがアセットストアで入れたテクスチャが→Paint Textureマークをクリックし、Edit　Textures→Add　Texture　と操作したときにadd terrain textureのセレクトで出てきませんどうしたらいいでしょうか。

説明わかりにくかったらすみません
言いたいことは、地面にテクスチャを貼りたいけどselectを押した後で草や砂みたいなテクスチャを選択するにはどうしたらいいのか教えて欲しいということです。

参考にさせてもらったサイト　https://gametukurikata.com/terrain/makefield