Пример #1
0
/**
 * Create the augmented knots vector and fill in matrix Xt with the spline basis vectors
 */
void basis_splines_endreps_local_v2(float *knots, int n_knots, int order, int *boundaries, int n_boundaries,  Eigen::MatrixXf &Xt) {
  assert(n_boundaries == 2 && boundaries[0] < boundaries[1]);
  int n_rows = boundaries[1] - boundaries[0]; // this is frames so evaluate at each frame we'll need
  int n_cols = n_knots + order;  // number of basis vectors we'll have at end 
  Xt.resize(n_cols, n_rows); // swapped to transpose later. This order lets us use it as a scratch space
  Xt.fill(0);
  int n_std_knots = n_knots + 2 * order;
  float std_knots[n_std_knots];

  // Repeat the boundary knots on there to ensure linear out side of knots
  for (int i = 0; i < order; i++) {
    std_knots[i] = boundaries[0];
  }
  // Our original boundary knots here
  for (int i = 0; i < n_knots; i++) {
    std_knots[i+order] = knots[i];
  }
  // Repeat the boundary knots on there to ensure linear out side of knots
  for (int i = 0; i < order; i++) {
    std_knots[i+order+n_knots] = boundaries[1];
  }
  // Evaluate our basis splines at each frame.
  for (int i = boundaries[0]; i < boundaries[1]; i++) {
    int idx = -1;
    // find index such that i >= knots[idx] && i < knots[idx+1]
    float *val = std::upper_bound(std_knots, std_knots + n_std_knots - 1, 1.0f * i);
    idx = val - std_knots - 1;
    assert(idx >= 0);
    float *f = Xt.data() + i * n_cols + idx - (order - 1); //column offset
    basis_spline_xi_v2(std_knots, n_std_knots, order, idx, i, f);
  }
  // Put in our conventional format where each column is a basis vector
  Xt.transposeInPlace();
}
Пример #2
0
void VertexBufferObject::update(const Eigen::MatrixXf& M)
{
  assert(id != 0);
  glBindBuffer(GL_ARRAY_BUFFER, id);
  glBufferData(GL_ARRAY_BUFFER, sizeof(float)*M.size(), M.data(), GL_DYNAMIC_DRAW);
  rows = M.rows();
  cols = M.cols();
  check_gl_error();
}
Пример #3
0
	void PlotBorderPixels(Eigen::MatrixXf& mat, const Graph& graph, WeightMap weights, BorderPixelMap border_pixels)
	{
		float* p = mat.data();
		for(auto eid : as_range(boost::edges(graph))) {
			float v = weights[eid];
			for(unsigned int pid : boost::get(border_pixels, eid)) {
				p[pid] = v;
			}
		}
	}
Пример #4
0
void run ()
{

  const double tol = argument[2];

#ifdef MRTRIX_UPDATED_API

  const Eigen::MatrixXf in1 = load_matrix<float> (argument[0]);
  const Eigen::MatrixXf in2 = load_matrix<float> (argument[1]);
  
  if (in1.rows() != in2.rows() || in1.cols() != in2.cols())
    throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + "\" do not have matching sizes"
                     " (" + str(in1.rows()) + "x" + str(in1.cols()) + " vs " + str(in2.rows()) + "x" + str(in2.cols()) + ")");
  
  const size_t numel = in1.size();
  for (size_t i = 0; i != numel; ++i) {
    if (std::abs (*(in1.data()+i) - *(in2.data()+i)) > tol)
      throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + " do not match within specified precision of " + str(tol)
                       + " (" + str(*(in1.data()+i)) + " vs " + str(*(in2.data()+i)) + ")");
  }
  
#else

  Math::Matrix<float> in1, in2;
  in1.load (argument[0]);
  in2.load (argument[1]);
  
  if (in1.rows() != in2.rows() || in1.columns() != in2.columns())
    throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + "\" do not have matching sizes"
                     " (" + str(in1.rows()) + "x" + str(in1.columns()) + " vs " + str(in2.rows()) + "x" + str(in2.columns()) + ")");
            
  const size_t numel = in1.rows() * in1.columns();
  for (size_t i = 0; i != numel; ++i) {
    if (std::abs (*(in1.ptr()+i) - *(in2.ptr()+i)) > tol)
      throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + " do not match within specified precision of " + str(tol)
                       + " (" + str(*(in1.ptr()+i)) + " vs " + str(*(in2.ptr()+i)) + ")");
  }               

#endif

  CONSOLE ("data checked OK");
}
Пример #5
0
void load( Archive & ar,
           Eigen::MatrixXf & t,
           const unsigned int file_version )
{
    int n0;
    ar >> BOOST_SERIALIZATION_NVP( n0 );
    int n1;
    ar >> BOOST_SERIALIZATION_NVP( n1 );
    t.resize( n0, n1 );
    ar >> make_array( t.data(), t.rows()*t.cols() );
}
Пример #6
0
void save( Archive & ar,
           const Eigen::MatrixXf & t,
           const unsigned int file_version )
{
    int n0 = t.rows();
    ar << BOOST_SERIALIZATION_NVP( n0 );
    int n1 = t.cols();
    ar << BOOST_SERIALIZATION_NVP( n1 );
    ar << boost::serialization::make_array( t.data(),
                                            t.rows()*t.cols() );
}
Пример #7
0
void AdaptClusterRadiusBySaliency(ImagePoints& points, const Eigen::MatrixXf& saliency, const Parameters& opt)
{
	// FIXME what is base?
	const float base = 0.5f;
	auto it_p = points.begin();
	auto it_p_end = points.end();
	auto it_s = saliency.data();
	for(; it_p!=it_p_end; ++it_p, ++it_s) {
		it_p->cluster_radius_px *= std::pow(base, -*it_s);
	}
}
Пример #8
0
void run ()
{

  const Eigen::MatrixXf in1 = load_matrix<float> (argument[0]);
  const Eigen::MatrixXf in2 = load_matrix<float> (argument[1]);
  
  if (in1.rows() != in2.rows() || in1.cols() != in2.cols())
    throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + "\" do not have matching sizes"
                     " (" + str(in1.rows()) + "x" + str(in1.cols()) + " vs " + str(in2.rows()) + "x" + str(in2.cols()) + ")");

  const size_t numel = in1.size();

  auto opt = get_options ("frac");
  if (opt.size()) {
  
    const double tol = opt[0][0];
    
    for (size_t i = 0; i != numel; ++i) {
      if (std::abs ((*(in1.data()+i) - *(in2.data()+i)) / (0.5 * (*(in1.data()+i) + *(in2.data()+i)))) > tol)
        throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + " do not match within fractional precision of " + str(tol)
                         + " (" + str(*(in1.data()+i)) + " vs " + str(*(in2.data()+i)) + ")");
    }
  
  } else {
  
    double tol = 0.0;
    opt = get_options ("abs");
    if (opt.size())
      tol = opt[0][0];

    for (size_t i = 0; i != numel; ++i) {
      if (std::abs (*(in1.data()+i) - *(in2.data()+i)) > tol)
        throw Exception ("matrices \"" + Path::basename (argument[0]) + "\" and \"" + Path::basename (argument[1]) + " do not match within absolute precision of " + str(tol)
                         + " (" + str(*(in1.data()+i)) + " vs " + str(*(in2.data()+i)) + ")");
    }
        
  }
  
  CONSOLE ("data checked OK");
}
Пример #9
0
void FiffStreamThread::sendRawBuffer(Eigen::MatrixXf m_matRawData)
{
    if(m_bIsSendingRawBuffer)
    {
//        qDebug() << "Send RawBuffer to client";

        m_qMutex.lock();

        FiffStream t_FiffStreamOut(&m_qSendBlock, QIODevice::WriteOnly);
        t_FiffStreamOut.write_float(FIFF_DATA_BUFFER,m_matRawData.data(),m_matRawData.rows()*m_matRawData.cols());

        m_qMutex.unlock();

    }
//    else
//    {
//        qDebug() << "Send RawBuffer is not activated";
//    }
}
Пример #10
0
void
readLDRFile(const std::string& file, Eigen::MatrixXf& data)
{
    std::ifstream in(file.c_str(), std::ios::in | std::ios::binary);
    in.seekg(0, std::ios::end);
    int size = in.tellg();
    in.seekg(0, std::ios::beg);
    
    int num_floats = size / (sizeof(float) / sizeof (char));
    int num_rows = num_floats / 6;
    data.resize(6, num_rows);

    float* row_arr = new float[num_floats];
    in.read((char*)(row_arr), size);

    float* data_arr = data.data();
    for (int k = 0; k < num_floats; k++)
        data_arr[k] = row_arr[k];

    data.transposeInPlace();

    in.close();
}
Пример #11
0
int main(int argc, char* argv[])
{
    try
    {
        // Select a device and display arrayfire info
        int device = argc > 1 ? std::atoi(argv[1]) : 0;
        af::setDevice(device);
        af::info();

        Eigen::MatrixXf C = Eigen::MatrixXf::Random(1e4, 50); // host array
        af::array in(1e4, 50, C.data());                      // copy host data to device

        af::array u, s_vec, vt;
        svd(u, s_vec, vt, in);
    }
    catch (af::exception& e)
    {
        std::cout << e.what() << '\n';

        return 1;
    }

    return 0;
}
Пример #12
0
void CloudAnalyzer2D::examinePointEvidence() {
  pointEvidence.clear();

  for (int r = 0; r < R->size(); ++r) {
    Eigen::MatrixXf total = Eigen::MatrixXf::Zero(newRows, newCols);

#pragma omp parallel for schedule(static)
    for (int i = 0; i < total.cols(); ++i) {
      for (int j = 0; j < total.rows(); ++j) {
        for (int k = 0; k < numZ; ++k) {
          const Eigen::Vector3d coord(i, j, k);
          const Eigen::Vector3i src =
              (R->at(r) * (coord - newZZ) + zeroZero)
                  .unaryExpr([](auto v) { return std::round(v); })
                  .cast<int>();

          if (src[0] < 0 || src[0] >= numX || src[1] < 0 || src[1] >= numY ||
              src[2] < 0 || src[2] >= numZ)
            continue;

          if (pointInVoxel->at(src))
            ++total(j, i);
        }
      }
    }

    double average, sigma;
    const float *dataPtr = total.data();
    std::tie(average, sigma) = place::aveAndStdev(
        dataPtr, dataPtr + total.size(), [](auto v) { return v; },
        [](auto v) -> bool { return v; });

    cv::Mat heatMap(newRows, newCols, CV_8UC1, cv::Scalar::all(255));
    for (int j = 0; j < heatMap.rows; ++j) {
      uchar *dst = heatMap.ptr<uchar>(j);
      for (int i = 0; i < heatMap.cols; ++i) {
        const double count = total(j, i);
        if (count > 0) {
          const int gray = cv::saturate_cast<uchar>(
              255.0 *
              ((count - average - sigma) / (3.0 * sigma) - 0.0 * sigma));
          dst[i] = 255 - gray;
        }
      }
    }

    if (FLAGS_preview && doors->size()) {
      std::cout << "Number of doors: " << doors->size() << std::endl;
      cv::Mat out;
      cv::cvtColor(heatMap, out, CV_GRAY2BGR);
      cv::Mat_<cv::Vec3b> _out = out;
      for (auto &d : *doors) {
        Eigen::Vector3d bl = d.corner * FLAGS_scale;
        bl[1] *= -1.0;
        bl = R->at(r).inverse() * bl;

        Eigen::Vector3d xAxis = d.xAxis;
        xAxis[1] *= -1.0;
        xAxis = R->at(r).inverse() * xAxis;

        Eigen::Vector3d zAxis = d.zAxis;
        zAxis[1] *= -1.0;
        zAxis = R->at(r).inverse() * zAxis;

        double w = d.w * FLAGS_scale;

        auto color = randomColor();
        for (int i = 0; i < w; ++i) {
          Eigen::Vector3d pix =
              (bl + i * xAxis + i * zAxis + newZZ).unaryExpr([](auto v) {
                return std::round(v);
              });

          if (pix[0] < 0 || pix[0] >= out.cols || pix[1] < 0 ||
              pix[1] >= out.rows)
            continue;

          _out(pix[1], pix[0]) = color;
        }
      }
      cv::rectshow(out);
    }

    pointEvidence.push_back(heatMap);

    if (FLAGS_preview)
      cv::rectshow(heatMap);
  }
}
Пример #13
0
std::vector<EigenComponent> solver_magma(const Eigen::MatrixXf& A, unsigned int num_ev)
{
	static MagmaSpectralSolver magma;

	magma_int_t N = A.rows();
	std::cout << "MAGMA Solver N=" << N << std::endl;

	magma_timestr_t start, end;
	float gpu_time;
	start = get_current_time();

	magma_int_t info;

	const float *h_A = A.data();

	float *h_R, *h_work;
	float *w1;
	magma_int_t *iwork;

	const char *uplo = MagmaLowerStr;
	const char *jobz = MagmaVecStr;

	/* Query for workspace sizes */
	float      aux_work[1];
	magma_int_t aux_iwork[1];
	std::cout << "Querying workspace size" << std::endl;
	magma_ssyevd( jobz[0], uplo[0],
	              N, h_R, N, w1,
	              aux_work,  -1,
	              aux_iwork, -1,
	              &info );
	magma_int_t lwork  = (magma_int_t) aux_work[0];
	magma_int_t liwork = aux_iwork[0];
	std::cout << lwork << " " << liwork << std::endl;

	std::cout << "Allocating" << std::endl;
	w1     = magma.malloc<float>(N  );
	h_R    = magma.hostmalloc<float>(N*N);
	h_work = magma.hostmalloc<float>(lwork);
	iwork  = magma.malloc<magma_int_t>(liwork);

	std::cout << "Copying" << std::endl;
	slacpy_( MagmaUpperLowerStr, &N, &N, h_A, &N, h_R, &N );

	std::cout << "Solving" << std::endl;
	magma_ssyevd(jobz[0], uplo[0],
	         N, h_R, N, w1,
	         h_work, lwork,
	         iwork, liwork,
	         &info);

	std::cout << "Collecting" << std::endl;
	// save eigenvectors and eigenvalues
	std::vector<EigenComponent> solution(std::min<int>(N, num_ev));
	for(unsigned int i=0; i<solution.size(); i++) {
		solution[i].eigenvalue = w1[i+1];
		Eigen::VectorXf ev(N);
		for(unsigned int j=0; j<N; j++) {
			ev[j] = *(h_R + i*N + j);
		}
		solution[i].eigenvector = ev;
	}

	std::cout << "Freeing" << std::endl;
	magma.free(w1);
	magma.hostfree(h_R);
	magma.hostfree(h_work);
	magma.free(iwork);

	end = get_current_time();

	gpu_time = GetTimerValue(start,end)/1000.;
	std::cout << "Time: " << gpu_time << std::endl;

	return solution;
}
Пример #14
0
	//input vectors as columns (Eigen defaults to column major storage)
	void calcMeanAndCovarWeighed(const Eigen::MatrixXf &input, const Eigen::VectorXd &inputWeights, Eigen::MatrixXf &out_covMat, Eigen::VectorXf &out_mean)
	{
		calcMeanAndCovarWeighed(input.data(),inputWeights.data(),input.rows(),input.cols(),out_covMat,out_mean);

	}
Пример #15
0
	//input vectors as columns (Eigen defaults to column major storage)
	void calcMeanWeighed(const Eigen::MatrixXf &input, const Eigen::VectorXd &inputWeights, Eigen::VectorXf &out_mean)
	{
		AALTO_ASSERT1(!input.IsRowMajor);
		calcMeanWeighed(input.data(),inputWeights.data(),input.rows(),input.cols(),out_mean);
	}
Пример #16
0
	// Compute d/df a^T*K*b
	Eigen::MatrixXf kernelGradient( const Eigen::MatrixXf & a, const Eigen::MatrixXf & b ) const {
		Eigen::MatrixXf g = 0*f_;
		lattice_.gradient( g.data(), a.data(), b.data(), a.rows() );
		return g;
	}
Пример #17
0
	Eigen::MatrixXf PointDensityImpl(const std::vector<T>& seeds, const Eigen::MatrixXf& target, Fx fx, Fy fy)
	{
		// radius of box in which to average cluster density
		constexpr int RHO_R = 3;
		constexpr float cMagicSoftener = 0.5f; // 0.62f;
		constexpr float cRangeLossMult = 1.001f;
		constexpr float cRange = 1.3886f;
		const int rows = target.rows();
		const int cols = target.cols();
		// range of kernel s.t. 99.9% of mass is covered
		Eigen::MatrixXf density = Eigen::MatrixXf::Zero(rows, cols);
		for(const T& s : seeds) {
			const int sx = std::round(fx(s));
			const int sy = std::round(fy(s));
			// compute point density as average over a box
			float rho_sum = 0.0f;
			unsigned int rho_num = 0;
			for(int i=-RHO_R; i<=+RHO_R; ++i) {
				for(int j=-RHO_R; j<=+RHO_R; ++j) {
					const int sxj = sx + j;
					const int syi = sy + i;
					if( 0 <= sxj && sxj < rows &&
						0 <= syi && syi < cols)
					{
						rho_sum += target(sxj, syi);
						rho_num ++;
					}
				}
			}
			if(rho_sum == 0.0f || rho_num == 0) {
				continue;
			}
			const float rho = rho_sum / static_cast<float>(rho_num);
			// seed corresponds to a kernel at position (x,y)
			// with sigma = 1/sqrt(pi*rho)
			// i.e. 1/sigma^2 = pi*rho
			// factor pi is already compensated in kernel
			const float sxf = fx(s);
			const float syf = fy(s);
			const float rho_soft = cMagicSoftener * rho;
			// kernel influence range
			const int R = static_cast<int>(std::ceil(cRange / std::sqrt(rho_soft)));
			const int xmin = std::max<int>(sx - R, 0);
			const int xmax = std::min<int>(sx + R, int(rows) - 1);
			const int ymin = std::max<int>(sy - R, 0);
			const int ymax = std::min<int>(sy + R, int(cols) - 1);
			for(int yi=ymin; yi<=ymax; yi++) {
				for(int xi=xmin; xi<=xmax; xi++) {
					float dx = static_cast<float>(xi) - sxf;
					float dy = static_cast<float>(yi) - syf;
					float d2 = dx*dx + dy*dy;
					float delta = rho_soft * KernelSquare(rho_soft*d2);
					density(xi, yi) += delta;
				}
			}
		}
		{
			const float* psrc = target.data();
			const float* psrc_end = psrc + rows*cols;
			float* pdst = density.data();
			for(; psrc!=psrc_end; ++psrc, ++pdst) {
				if(*psrc == 0.0f) {
					*pdst = 0.0f;
				}
			}
		}
		return cRangeLossMult * density;
	}
Пример #18
0
void TraceStoreCol::SplineLossyCompress(const std::string &strategy, int order, char *bad_wells, float *mad) {
  Eigen::MatrixXf Basis;
  vector<float> knots;
  FillInKnots(strategy, mFrames, knots);
  //  Eigen::Map<Eigen::MatrixXf, Eigen::Aligned> Basis(, compressed.n_frames, compressed.n_basis);
  if (!knots.empty()) {
    int boundaries[2];
    boundaries[0] = 0;
    boundaries[1] = mFrames;
    basis_splines_endreps_local_v2(&knots[0], knots.size(), order, boundaries, sizeof(boundaries)/sizeof(boundaries[0]), Basis);
  }
  Eigen::MatrixXf SX = (Basis.transpose() * Basis).inverse() * Basis.transpose();
  Eigen::MatrixXf Y(mFlowFrameStride, mFrames);
  //  Eigen::MatrixXf FlowMeans(mFlows, mFrames);

  //  FlowMeans.setZero();
  int good_wells = 0;
  char *bad_start = bad_wells;
  char *bad_end = bad_start + mFrameStride;
  while(bad_start != bad_end) {
    if (*bad_start++ == 0) {
      good_wells++;
    }
  }
  
  // if nothing good then skip it
  if (good_wells < MIN_SAMPLE_WELL) {
    return;
  }

  std::vector<ChipReduction> smoothed_avg(mFlows);
  int x_clip = mCols;
  int y_clip = mRows;
  if (mUseMeshNeighbors == 0) {
    x_clip = THUMBNAIL_SIZE;
    y_clip = THUMBNAIL_SIZE;
  }
  for (size_t flow_ix = 0; flow_ix < mFlows; flow_ix++) {
    smoothed_avg[flow_ix].Init(mRows, mCols, mFrames,
                               SMOOTH_REDUCE_STEP, SMOOTH_REDUCE_STEP,
                               y_clip, x_clip,
                               SMOOTH_REDUCE_STEP * SMOOTH_REDUCE_STEP * .4);
    for (size_t frame_ix = 0; frame_ix < mFrames; frame_ix++) {
      smoothed_avg[flow_ix].ReduceFrame(&mData[0] + flow_ix * mFrameStride + frame_ix * mFlowFrameStride, bad_wells, frame_ix);
    }
    smoothed_avg[flow_ix].SmoothBlocks(SMOOTH_REDUCE_REGION, SMOOTH_REDUCE_REGION);
  }

  float *y_start = Y.data();
  float *y_end = Y.data() + mData.size();
  int16_t *trace_start = &mData[0];
  while(y_start != y_end) {
    *y_start++ = *trace_start++;
  }

  // // get the flow means per frame.
  // for (size_t frame_ix = 0; frame_ix < mFrames; frame_ix++) {
  //   for(size_t flow_ix = 0; flow_ix < mFlows; flow_ix++) {
  //     float *start = Y.data() + mFlowFrameStride * frame_ix + flow_ix * mFrameStride;
  //     float *end = start + mFrameStride;
  //     float *sum = &FlowMeans(flow_ix, frame_ix);
  //     char *bad = bad_wells;
  //     while (start != end) {
  //       if (*bad == 0) {
  //         *sum += *start;
  //       }
  //       start++;
  //       bad++;
  //     }
  //     *sum /= good_wells;
  //   }
  // }

  // subtract off flow,frame avg
  for (size_t frame_ix = 0; frame_ix < mFrames; frame_ix++) {
    for(size_t flow_ix = 0; flow_ix < mFlows; flow_ix++) {
      float *start = Y.data() + mFlowFrameStride * frame_ix + flow_ix * mFrameStride;
      float *end = start + mFrameStride;
      for (size_t row = 0; row < mRows; row++) {
        for (size_t col = 0; col < mCols; col++) {
          float avg = smoothed_avg[flow_ix].GetSmoothEst(row, col, frame_ix);
          *start++ -= avg;
        }
      }
    }
  }


  // // subtract them off
  // Eigen::VectorXf col_mean = Y.colwise().sum();
  // col_mean /= Y.rows();

  // for (int i = 0; i < Y.cols(); i++) {
  //   Y.col(i).array() -= col_mean.coeff(i);
  // }

  // Get coefficients to solve
  Eigen::MatrixXf B = Y * SX.transpose();
  // Uncompress data into yhat matrix
  Eigen::MatrixXf Yhat = B * Basis.transpose();


  // add the flow/frame averages back
  for (size_t frame_ix = 0; frame_ix < mFrames; frame_ix++) {
    for(size_t flow_ix = 0; flow_ix < mFlows; flow_ix++) {
      float *start = Y.data() + mFlowFrameStride * frame_ix + flow_ix * mFrameStride;
      float *end = start + mFrameStride;
      float *hstart = Yhat.data() + mFlowFrameStride * frame_ix + flow_ix * mFrameStride;
      for (size_t row = 0; row < mRows; row++) {
        for (size_t col = 0; col < mCols; col++) {
          float avg = smoothed_avg[flow_ix].GetSmoothEst(row, col, frame_ix);
          *start++ += avg;
          *hstart++ += avg;
        }
      }
    }
  }

  // for (size_t frame_ix = 0; frame_ix < mFrames; frame_ix++) {
  //   for(size_t flow_ix = 0; flow_ix < mFlows; flow_ix++) {
  //     float *start = Y.data() + mFlowFrameStride * frame_ix + flow_ix * mFrameStride;
  //     float *hstart = Yhat.data() + mFlowFrameStride * frame_ix + flow_ix * mFrameStride;
  //     float *end = start + mFrameStride;
  //     float avg = FlowMeans(flow_ix, frame_ix);
  //     while (start != end) {
  //       *start++ += avg;
  //       *hstart++ += avg;
  //     }
  //   }
  // }

  // for (int i = 0; i < Yhat.cols(); i++) {
  //   Yhat.col(i).array() += col_mean.coeff(i);
  //   Y.col(i).array() += col_mean.coeff(i);
  // }

  float *yhat_start = Yhat.data();
  float *yhat_end = Yhat.data() + mData.size();
  trace_start = &mData[0];
  while(yhat_start != yhat_end) {
    *trace_start++ = (int)(*yhat_start + .5);
    yhat_start++;
  }

  Y = Y - Yhat;
  Eigen::VectorXf M = Y.rowwise().squaredNorm();

  for (size_t flow_ix = 0; flow_ix < mFlows; flow_ix++) {
    float *mad_start = mad;
    float *mad_end = mad_start + mFrameStride;
    float *m_start = M.data() + flow_ix * mFrameStride;
    while (mad_start != mad_end) {
      *mad_start += *m_start;
      mad_start++;
      m_start++;
    }
  }

  float *mad_start = mad;
  float *mad_end = mad + mFrameStride;
  int norm_factor = mFlows * mFrames;
  while (mad_start != mad_end) {
    *mad_start /= norm_factor;
    mad_start++;
  }
}
Пример #19
0
bool TraceStoreCol::PcaLossyCompressChunk(int row_start, int row_end,
                                          int col_start, int col_end,
                                          int num_rows, int num_cols, int num_frames,
                                          int frame_stride,
                                          int flow_ix, int flow_frame_stride,
                                          short *data, bool replace,
                                          float *ssq, char *filters,
                                          int row_step, int col_step,
                                          int num_pca) {

  Eigen::MatrixXf Ysub, Y, S, Basis;

  int loc_num_wells = (col_end - col_start) * (row_end - row_start);
  int loc_num_cols = col_end - col_start;

  // Take a sample of the data at rate step, avoiding flagged wells
  // Count the good rows
  int sample_wells = 0;
  for (int row_ix = row_start; row_ix < row_end; row_ix+= row_step) {
    char *filt_start = filters + row_ix * num_cols + col_start;
    char *filt_end = filt_start + loc_num_cols;
    while (filt_start < filt_end) {
      if (*filt_start == 0) {
        sample_wells++;
      }
      filt_start += col_step;
    }
  }
  // try backing off to every well rather than just sampled if we didn't get enough
  if (sample_wells < MIN_SAMPLE_WELL) {
    row_step = 1;
    col_step = 1;
    int sample_wells = 0;
    for (int row_ix = row_start; row_ix < row_end; row_ix+= row_step) {
      char *filt_start = filters + row_ix * num_cols + col_start;
      char *filt_end = filt_start + loc_num_cols;
      while (filt_start < filt_end) {
        if (*filt_start == 0) {
          sample_wells++;
        }
        filt_start += col_step;
      }
    }
  }

  if (sample_wells < MIN_SAMPLE_WELL) {
    return false; // just give up
  }

  // Got enough data to work with, zero out the ssq array for accumulation
  for (int row_ix = row_start; row_ix < row_end; row_ix++) {
    float *ssq_start = ssq + row_ix * num_cols + col_start;
    float *ssq_end = ssq_start + loc_num_cols;
    while (ssq_start != ssq_end) {
      *ssq_start++ = 0;
    }
  }
  // Copy the sampled data in Matrix, frame major
  Ysub.resize(sample_wells, num_frames);
  for (int frame_ix = 0; frame_ix < (int)num_frames; frame_ix++) {
    int sample_offset = 0;
    for (int row_ix = row_start; row_ix < row_end; row_ix+=row_step) {
      size_t store_offset = row_ix * num_cols + col_start;
      char *filt_start = filters + store_offset;
      char *filt_end = filt_start + loc_num_cols;
      int16_t *trace_start = data + (flow_frame_stride * frame_ix) + (flow_ix * frame_stride) + store_offset;
      float *ysub_start = Ysub.data() + sample_wells * frame_ix + sample_offset;
      while (filt_start < filt_end) {
        if (*filt_start == 0) {
          *ysub_start = *trace_start;
          ysub_start++;
          sample_offset++;
        }
        trace_start += col_step;
        filt_start += col_step;
      }
    }
  }

  // Copy in all the data into working matrix
  Y.resize(loc_num_wells, (int)num_frames);
  for (int frame_ix = 0; frame_ix < (int)num_frames; frame_ix++) {
    for (int row_ix = row_start; row_ix < row_end; row_ix++) {
      size_t store_offset = row_ix * num_cols + col_start;
      int16_t *trace_start = data + (flow_frame_stride * frame_ix) + (flow_ix * frame_stride) + store_offset;
      int16_t *trace_end = trace_start + loc_num_cols;
      float * y_start = Y.data() + loc_num_wells * frame_ix + (row_ix - row_start) * loc_num_cols;
      while( trace_start != trace_end ) {
        *y_start++ = *trace_start++;
      }
    }
  }
  Eigen::VectorXf col_mean = Y.colwise().sum();
  col_mean /= Y.rows();

  for (int i = 0; i < Y.cols(); i++) {
    Y.col(i).array() -= col_mean.coeff(i);
  }
  // Create scatter matrix
  S = Ysub.transpose() * Ysub;
  // Compute the eigenvectors
  Eigen::SelfAdjointEigenSolver<Eigen::MatrixXf> es;
  es.compute(S);
  Eigen::MatrixXf Pca_Basis = es.eigenvectors();
  Eigen::VectorXf Pca_Values = es.eigenvalues();
  // Copy top eigen vectors into basis for projection
  Basis.resize(num_frames, num_pca);
  for (int i = 0; i < Basis.cols(); i++) {
    //    Basis.col(i) = es.eigenvectors().col(es.eigenvectors().cols() - i -1);
    Basis.col(i) = Pca_Basis.col(Pca_Basis.cols() - i - 1);
  }
  // Create solver matrix, often not a good way of solving things but eigen vectors should be stable and fast
  Eigen::MatrixXf SX = (Basis.transpose() * Basis).inverse() * Basis.transpose();
  // Get coefficients to solve
  Eigen::MatrixXf B = Y * SX.transpose();
  // Uncompress data into yhat matrix
  Eigen::MatrixXf Yhat = B * Basis.transpose();

  for (int i = 0; i < Yhat.cols(); i++) {
    Yhat.col(i).array() += col_mean.coeff(i);
    Y.col(i).array() += col_mean.coeff(i);
  }
  
  // H5File h5("pca_lossy.h5");
  // h5.Open();
  // char buff[256];
  // snprintf(buff, sizeof(buff), "/Y_%d_%d_%d", flow_ix, row_start, col_start);
  // H5Eigen::WriteMatrix(h5, buff, Y);
  // snprintf(buff, sizeof(buff), "/Yhat_%d_%d_%d", flow_ix, row_start, col_start);
  // H5Eigen::WriteMatrix(h5, buff, Yhat);
  // snprintf(buff, sizeof(buff), "/Basis_%d_%d_%d", flow_ix, row_start, col_start);
  // H5Eigen::WriteMatrix(h5, buff, Basis);
  // h5.Close();
  // Copy data out of yhat matrix into original data structure, keeping track of residuals
  for (int frame_ix = 0; frame_ix < (int)num_frames; frame_ix++) {
    for (int row_ix = row_start; row_ix < row_end; row_ix++) {
      size_t store_offset = row_ix * num_cols + col_start;
      int16_t *trace_start = data + flow_frame_stride * frame_ix + flow_ix * frame_stride + store_offset;
      int16_t *trace_end = trace_start + loc_num_cols;
      float * ssq_start = ssq + store_offset;
      size_t loc_offset = (row_ix - row_start) * loc_num_cols;
      float * y_start = Y.data() + loc_num_wells * frame_ix + loc_offset;
      float * yhat_start = Yhat.data() + loc_num_wells * frame_ix + loc_offset;
      while( trace_start != trace_end ) {
        if (replace) {
          *trace_start = (int16_t)(*yhat_start + .5);
        }
        float val = *y_start - *yhat_start;
        *ssq_start += val * val;
        y_start++;
        yhat_start++;
        trace_start++;
        ssq_start++;
      }
    }
  }

  // divide ssq data out for per frame avg
  for (int row_ix = row_start; row_ix < row_end; row_ix++) {
    size_t store_offset = row_ix * num_cols + col_start;
    float * ssq_start = ssq + store_offset;
    float * ssq_end = ssq_start + loc_num_cols;
    while (ssq_start != ssq_end) {
      *ssq_start /= num_frames;
      ssq_start++;
    }
  }
  return true;
}
Пример #20
0
void TraceStoreCol::SplineLossyCompress(const std::string &strategy, int order, int flow_ix, char *bad_wells, 
                                        float *mad, size_t num_rows, size_t num_cols, size_t num_frames, size_t num_flows,
                                        int use_mesh_neighbors, size_t frame_stride, size_t flow_frame_stride, int16_t *data) {
  Eigen::MatrixXf Basis;
  vector<float> knots;
  FillInKnots(strategy, num_frames, knots);
  if (!knots.empty()) {
    int boundaries[2];
    boundaries[0] = 0;
    boundaries[1] = num_frames;
    basis_splines_endreps_local_v2(&knots[0], knots.size(), order, boundaries, sizeof(boundaries)/sizeof(boundaries[0]), Basis);
  }
  Eigen::MatrixXf SX = (Basis.transpose() * Basis).inverse() * Basis.transpose();
  Eigen::MatrixXf Y(frame_stride, num_frames);
  //  Eigen::MatrixXf FlowMeans(num_flows, num_frames);

  //  FlowMeans.setZero();
  int good_wells = 0;
  char *bad_start = bad_wells;
  char *bad_end = bad_start + frame_stride;
  while(bad_start != bad_end) {
    if (*bad_start++ == 0) {
      good_wells++;
    }
  }
  
  // if nothing good then skip it
  if (good_wells < MIN_SAMPLE_WELL) {
    return;
  }

  ChipReduction smoothed_avg;
  int x_clip = num_cols;
  int y_clip = num_rows;
  if (use_mesh_neighbors == 0) {
    x_clip = THUMBNAIL_SIZE;
    y_clip = THUMBNAIL_SIZE;
  }

  smoothed_avg.Init(num_rows, num_cols, num_frames,
                    SMOOTH_REDUCE_STEP, SMOOTH_REDUCE_STEP,
                    y_clip, x_clip,
                    SMOOTH_REDUCE_STEP * SMOOTH_REDUCE_STEP * .4);
  for (size_t frame_ix = 0; frame_ix < num_frames; frame_ix++) {
    smoothed_avg.ReduceFrame(data + flow_ix * frame_stride + frame_ix * flow_frame_stride, bad_wells, frame_ix);
  }
  smoothed_avg.SmoothBlocks(SMOOTH_REDUCE_REGION, SMOOTH_REDUCE_REGION);


  for (size_t frame_ix = 0; frame_ix < num_frames; frame_ix++) {
    float *y_start = Y.data() + frame_ix * frame_stride;
    float *y_end = y_start + frame_stride;
    int16_t *trace_start = data + flow_ix * frame_stride + frame_ix * flow_frame_stride;
    while(y_start != y_end) {
      *y_start++ = *trace_start++;
    }
  }
    
  // subtract off flow,frame avg
  for (size_t frame_ix = 0; frame_ix < num_frames; frame_ix++) {
    float *start = Y.data() + frame_stride * frame_ix;
    float *end = start + frame_stride;
    for (size_t row = 0; row < num_rows; row++) {
      for (size_t col = 0; col < num_cols; col++) {
        float avg = smoothed_avg.GetSmoothEst(row, col, frame_ix);
        *start++ -= avg;
      }
    }
  }

  // Get coefficients to solve
  Eigen::MatrixXf B = Y * SX.transpose();
  // Uncompress data into yhat matrix
  Eigen::MatrixXf Yhat = B * Basis.transpose();


  // add the flow/frame averages back
  for (size_t frame_ix = 0; frame_ix < num_frames; frame_ix++) {
    float *start = Y.data() + frame_stride * frame_ix;
    float *end = start + frame_stride;
    float *hstart = Yhat.data() + frame_stride * frame_ix;
    for (size_t row = 0; row < num_rows; row++) {
      for (size_t col = 0; col < num_cols; col++) {
        float avg = smoothed_avg.GetSmoothEst(row, col, frame_ix);
        *start++ += avg;
        *hstart++ += avg;
      }
    }
  }

  for (size_t frame_ix = 0; frame_ix < num_frames; frame_ix++) {
    float *yhat_start = Yhat.data() + frame_ix * frame_stride;
    float *yhat_end = yhat_start + frame_stride;
    int16_t *trace_start = data + flow_ix * frame_stride + frame_ix * flow_frame_stride;
    while(yhat_start != yhat_end) {
      *trace_start++ = (int)(*yhat_start + .5f);
      yhat_start++;
    }
  }

  Y = Y - Yhat;
  Eigen::VectorXf M = Y.rowwise().squaredNorm();

  float *mad_start = mad;
  float *mad_end = mad_start + frame_stride;
  float *m_start = M.data();
  while (mad_start != mad_end) {
    *mad_start += *m_start;
    mad_start++;
    m_start++;
  }

  mad_start = mad;
  mad_end = mad + frame_stride;
  int norm_factor = num_frames;// num_flows * num_frames;
  while (mad_start != mad_end) {
    *mad_start /= norm_factor;
    mad_start++;
  }
}