static typename std::enable_if<
std::is_same<Border, ValidConvolution>::value, void>::type
Convolution(const arma::Mat<eT>& input,
const arma::Mat<eT>& filter,
arma::Mat<eT>& output,
const size_t dW = 1,
const size_t dH = 1)
{
output = arma::zeros<arma::Mat<eT> >((input.n_rows - filter.n_rows + 1) /
dW, (input.n_cols - filter.n_cols + 1) / dH);
// It seems to be about 3.5 times faster to use pointers instead of
// filter(ki, kj) * input(leftInput + ki, topInput + kj) and output(i, j).
eT* outputPtr = output.memptr();
for (size_t j = 0; j < output.n_cols; ++j)
{
for (size_t i = 0; i < output.n_rows; ++i, outputPtr++)
{
const eT* kernelPtr = filter.memptr();
for (size_t kj = 0; kj < filter.n_cols; ++kj)
{
const eT* inputPtr = input.colptr(kj + j * dW) + i * dH;
for (size_t ki = 0; ki < filter.n_rows; ++ki, ++kernelPtr, ++inputPtr)
*outputPtr += *kernelPtr * (*inputPtr);
}
}
}
}
std::vector<double> extract_column_vector(const arma::Mat<double>& data, long index) {
if (index<0 || index >= long(data.n_cols))
throw std::range_error(join("Index out of range: ", index));
const long n_rows = data.n_rows;
const double* memptr = data.colptr(index);
std::vector<double> result(memptr, memptr + n_rows);
return std::move(result);
}
void MainWindow::selectCorr(int idx) {
int mapId = _mapid(idx) - 1;
int k = 0;
for (int i = 0; i < _imageBuffer.n_rows; i++) {
for (int j = 0; j < _imageBuffer.n_cols; j++) {
if (std::isnan(_imageBuffer(i,j))) {
continue;
}
float corr = crossCorrelation(_dataT.colptr(mapId), _dataT.colptr(k), _dataT.n_rows);
if (std::isnan(corr)) {
continue;
}
_imageBuffer(i, j) = corr;
k++;
}
}
_mapItem->setRange(-1, 1);
_mapItem->refresh();
}
void CF<FactorizerType>::InsertNeighbor(const size_t queryIndex,
const size_t pos,
const size_t neighbor,
const double value,
arma::Mat<size_t>& recommendations,
arma::mat& values) const
{
// We only memmove() if there is actually a need to shift something.
if (pos < (recommendations.n_rows - 1))
{
const int len = (values.n_rows - 1) - pos;
memmove(values.colptr(queryIndex) + (pos + 1),
values.colptr(queryIndex) + pos,
sizeof(double) * len);
memmove(recommendations.colptr(queryIndex) + (pos + 1),
recommendations.colptr(queryIndex) + pos,
sizeof(size_t) * len);
}
// Now put the new information in the right index.
values(pos, queryIndex) = value;
recommendations(pos, queryIndex) = neighbor;
}
void LSHSearch<SortPolicy>::InsertNeighbor(arma::mat& distances,
arma::Mat<size_t>& neighbors,
const size_t queryIndex,
const size_t pos,
const size_t neighbor,
const double distance)
{
// We only memmove() if there is actually a need to shift something.
if (pos < (distances.n_rows - 1))
{
const size_t len = (distances.n_rows - 1) - pos;
memmove(distances.colptr(queryIndex) + (pos + 1),
distances.colptr(queryIndex) + pos,
sizeof(double) * len);
memmove(neighbors.colptr(queryIndex) + (pos + 1),
neighbors.colptr(queryIndex) + pos,
sizeof(size_t) * len);
}
// Now put the new information in the right index.
distances(pos, queryIndex) = distance;
neighbors(pos, queryIndex) = neighbor;
}
void FastMKS<KernelType, TreeType>::InsertNeighbor(arma::Mat<size_t>& indices,
arma::mat& products,
const size_t queryIndex,
const size_t pos,
const size_t neighbor,
const double distance)
{
// We only memmove() if there is actually a need to shift something.
if (pos < (products.n_rows - 1))
{
int len = (products.n_rows - 1) - pos;
memmove(products.colptr(queryIndex) + (pos + 1),
products.colptr(queryIndex) + pos,
sizeof(double) * len);
memmove(indices.colptr(queryIndex) + (pos + 1),
indices.colptr(queryIndex) + pos,
sizeof(size_t) * len);
}
// Now put the new information in the right index.
products(pos, queryIndex) = distance;
indices(pos, queryIndex) = neighbor;
}
void MainWindow::mousePressed(QFloatImageItem* self, QGraphicsSceneMouseEvent* event) {
QPoint pos = event->pos().toPoint();
int lg = pos.x();
int lt = pos.y();
if (lg < 91) {
lg = -180 + (91 - lg) * 2;
} else {
lg = 180 - (lg - 91) * 2;
}
if (lt < 45) {
lt = (45 - lt) * 2;
} else {
lt = -(lt - 45) * 2;
}
cout << "Long: " << lg << " / Lati: " << lt << endl;
if (ui.showCorr->isChecked()) {
int idx = pos.y() * _imageBuffer.n_rows + pos.x();
selectCorr(idx);
clearGraphs();
} else if (ui.showMonth->isChecked()) {
if (_tracePath.elementCount() == 0) {
_tracePath.moveTo(pos);
} else {
_tracePath.lineTo(pos);
}
_traceItem->setPath(_tracePath);
int idx = pos.y() * _imageBuffer.n_rows + pos.x();
ui.customPlot->xAxis->setLabel("month");
ui.customPlot->yAxis->setLabel("Temp");
QVector<double> xTicks;
QVector<QString> xLabels;
for (int i = 0; i < _dataT.n_rows; i += _dataT.n_rows / 10) {
xTicks << i;
xLabels << QString("%1/%2").arg(i / 12 + ui.startingYear->value()).arg(i % 12 + 1, 2, 10, QChar('0'));
}
ui.customPlot->xAxis->setAutoTicks(false);
ui.customPlot->xAxis->setAutoTickStep(false);
ui.customPlot->xAxis->setAutoTickLabels(false);
ui.customPlot->xAxis->setTickVector(xTicks);
ui.customPlot->xAxis->setTickVectorLabels(xLabels);
int mapId = _mapid(idx) - 1;
float *colData = _dataT.colptr(mapId);
QVector<double> xdata, ydata;
for (int i = 0; i < _dataT.n_rows; i++) {
xdata.append(i);
ydata.append(colData[i]);
}
ui.customPlot->addGraph(ui.customPlot->xAxis, ui.customPlot->yAxis);
int lastGraph = ui.customPlot->graphCount() - 1;
ui.customPlot->graph(lastGraph)->setData(xdata, ydata);
QPen lineColor(__hsv100[(lastGraph) % 100] & 0xaaffffff);
ui.customPlot->graph(lastGraph)->setPen(lineColor);
ui.customPlot->graph(lastGraph)->setName(QString("(%1,%2)").arg(lg).arg(lt));
ui.customPlot->graph(lastGraph)->setSelectable(true);
ui.customPlot->graph(lastGraph)->setProperty("x", QVariant(pos.x()));
ui.customPlot->graph(lastGraph)->setProperty("y", QVariant(pos.y()));
ui.customPlot->graph(lastGraph)->setProperty("mapid", QVariant(mapId));
ui.customPlot->graph(lastGraph)->setProperty("graphid", QVariant(lastGraph));
ui.customPlot->rescaleAxes();
ui.customPlot->replot();
}
}
arma::Col<eT> Element(arma::Mat<eT>& input, const size_t colNum)
{
return arma::Col<eT>(input.colptr(colNum), input.n_rows, false, true);
}