bool ShiftManipulator::preProcessing()
{
    if (m_firstrun) {
        // If we have an NCS, create a child command for each element.
        if (cells().count() > 1) { // non-contiguous selection
            // Sort the elements by their top row.
            if (m_direction == ShiftBottom) {
                qStableSort(cells().begin(), cells().end(), topRowLessThan);
            } else { // ShiftRight
                qStableSort(cells().begin(), cells().end(), leftColumnLessThan);
            }
            // Create sub-commands.
            const KCRegion::ConstIterator end(constEnd());
            for (KCRegion::ConstIterator it = constBegin(); it != end; ++it) {
                ShiftManipulator *const command = new ShiftManipulator(this);
                command->setSheet(m_sheet);
                command->add(KCRegion((*it)->rect(), (*it)->sheet()));
                if (m_mode == Delete) {
                    command->setReverse(true);
                }
                command->setDirection(m_direction);
            }
        } else { // contiguous selection
            m_sheet->cellStorage()->startUndoRecording();
        }
    }
    return KCAbstractRegionCommand::preProcessing();
}

Bitmap FCSVisualizer::visualizeDensity(const FCSFile &file, const FCSProcessor &processor, int axisA, int axisB, int imageSize, int clusterFilter, const QuartileRemap &params)
{
    Grid2f cells(imageSize, imageSize, 0.0f);
    const int borderSize = 1;

    for (const MathVectorf &sample : file.transformedSamples)
    {
        if (clusterFilter != -1 && processor.clustering.getClusterIndex(sample) != clusterFilter)
            continue;

        vec2f v;
        v.x = sample[axisA];
        v.y = 1.0f - sample[axisB];

        //if (v.x < 0.0f || v.y < 0.0f || v.x > 1.0f || v.y > 1.0f) cout << "bounds: " << v << endl;

        vec2i coord = math::round(v * (float)imageSize);
        if (cells.isValidCoordinate(coord) &&
                coord.x >= borderSize && coord.x < imageSize - borderSize &&
                coord.y >= borderSize && coord.y < imageSize - borderSize)
        {
            cells(coord)++;
        }
    }

    QuartileRemap paramsFinal = params;
    if (params.quartiles.size() == 0)
    {
        vector<float> nonzeroValues;
        for (auto &v : cells)
            if (v.value > 1.0f) nonzeroValues.push_back(v.value);
        std::sort(nonzeroValues.begin(), nonzeroValues.end());

        if (nonzeroValues.size() == 0)
            nonzeroValues.push_back(1.0f);

        paramsFinal.quartiles.resize(8);
        paramsFinal.quartiles[0] = 0.0f;
        paramsFinal.quartiles[1] = nonzeroValues[(int)(nonzeroValues.size() * 0.2f)];
        paramsFinal.quartiles[2] = nonzeroValues[(int)(nonzeroValues.size() * 0.4f)];
        paramsFinal.quartiles[3] = nonzeroValues[(int)(nonzeroValues.size() * 0.6f)];
        paramsFinal.quartiles[4] = nonzeroValues[(int)(nonzeroValues.size() * 0.7f)];
        paramsFinal.quartiles[5] = nonzeroValues[(int)(nonzeroValues.size() * 0.85f)];
        paramsFinal.quartiles[6] = nonzeroValues[(int)(nonzeroValues.size() * 0.98f)];
        paramsFinal.quartiles[7] = nonzeroValues.back();
        //params.quartiles = { 0.0f, 3.0f, 6.0f, 12.0f, 20.0f, 50.0f, 200.0f, 400.0f };
        //paramsFinal.print();
    }

    Bitmap result(imageSize, imageSize);
    for (auto &v : cells)
    {
        float intensity = paramsFinal.transform(v.value) * 255.0f;
        unsigned char c = util::boundToByte(intensity);
        result(v.x, v.y) = vec4uc(c, c, c, 255);
    }
    return result;
}

void Maze::setWall(pointT p1, pointT p2, bool state)
{
	if (!pointInBounds(p1) || !pointInBounds(p2))
		Error("Point is not in bounds for maze");
	cells(p1.row, p1.col).walls[neighborDir(p1, p2)] = state;
	cells(p2.row, p2.col).walls[neighborDir(p2, p1)] = state;
	if (!configured) configureGraphics();
	drawWallsForCell(p1);
	UpdateDisplay();
}

void Maze::drawWallsForCell(pointT p)
{
	MovePen(originX + p.col*cellSize, originY + p.row*cellSize);
	SetPenColor(cells(p.row, p.col).walls[South] ? "Black" : "White");
	DrawLine(cellSize, 0);
	SetPenColor(cells(p.row, p.col).walls[East] ? "Black" : "White");
	DrawLine(0, cellSize);
	SetPenColor(cells(p.row, p.col).walls[North] ? "Black" : "White");
	DrawLine(-cellSize, 0);
	SetPenColor(cells(p.row, p.col).walls[West] ? "Black" : "White");
	DrawLine(0, -cellSize);
}

Foam::List<Foam::FixedList<Foam::label, 8>> Foam::block::cells() const
{
    const label ni = density().x();
    const label nj = density().y();
    const label nk = density().z();

    List<FixedList<label, 8>> cells(nCells());

    label celli = 0;

    for (label k=0; k<nk; k++)
    {
        for (label j=0; j<nj; j++)
        {
            for (label i=0; i<ni; i++)
            {
                cells[celli][0] = pointLabel(i,   j,   k);
                cells[celli][1] = pointLabel(i+1, j,   k);
                cells[celli][2] = pointLabel(i+1, j+1, k);
                cells[celli][3] = pointLabel(i,   j+1, k);
                cells[celli][4] = pointLabel(i,   j,   k+1);
                cells[celli][5] = pointLabel(i+1, j,   k+1);
                cells[celli][6] = pointLabel(i+1, j+1, k+1);
                cells[celli][7] = pointLabel(i,   j+1, k+1);

                celli++;
            }
        }
    }

    return cells;
}

Eigen::MatrixXd
TargetField::as_cells() const {
  Eigen::MatrixXd cells(num_cells_, num_cells_);
  cells.setZero();

  return cells;
};

	bool HyperBlockingAsyncResult::publishResult( ResultPtr& result, Common::AsyncResultSink* asyncResultSink ) {
		if( result->is_error() ) {
			future->cancel();
			int error;
			String error_msg;
			result->get_error( error, error_msg );
			Common::HypertableException exception( error, error_msg );
			asyncResultSink->failure( exception );
			throw exception;
		}
		else if( result->is_scan() ) {
			Hypertable::Cells _cells;
			result->get_cells( _cells );
			Common::Cells cells( &_cells );
			switch( asyncResultSink->scannedCells(reinterpret_cast<int64_t>(result->get_scanner()), cells) ) {
				case Common::ACR_Cancel:
						result->get_scanner()->cancel();
						break;
					case Common::ACR_Abort:
						future->cancel();
						return false;
					default:
						break;
			}
			return true;
		}
		return true;
	}

Foam::labelList Foam::meshToMesh::maskCells
(
    const polyMesh& src,
    const polyMesh& tgt
) const
{
    boundBox intersectBb
    (
        max(src.bounds().min(), tgt.bounds().min()),
        min(src.bounds().max(), tgt.bounds().max())
    );

    intersectBb.inflate(0.01);

    const cellList& srcCells = src.cells();
    const faceList& srcFaces = src.faces();
    const pointField& srcPts = src.points();

    DynamicList<label> cells(src.size());
    forAll(srcCells, srcI)
    {
        boundBox cellBb(srcCells[srcI].points(srcFaces, srcPts), false);
        if (intersectBb.overlaps(cellBb))
        {
            cells.append(srcI);
        }
    }

  void extract_seed_points( MeshSegmentT const & mesh, SeedPointContainerT & seed_points )
  {
    typedef typename viennagrid::result_of::cell_id<MeshSegmentT>::type CellIDType;
    typedef typename viennagrid::result_of::const_cell_handle<MeshSegmentT>::type ConstCellHandleType;

    typedef typename viennagrid::result_of::const_cell_range<MeshSegmentT>::type CellRangeType;
    typedef typename viennagrid::result_of::iterator<CellRangeType>::type CellIteratorType;

    CellRangeType cells(mesh);

    if (!cells.empty())
    {
      typedef std::map<CellIDType, ConstCellHandleType> UnvisitedCellMapType;
      UnvisitedCellMapType unvisited_cells;

      for (CellIteratorType cit = cells.begin(); cit != cells.end(); ++cit)
        unvisited_cells[ cit->id() ] = cit.handle();

      while (!unvisited_cells.empty())
      {
        for (CellIteratorType cit = cells.begin(); cit != cells.end(); ++cit)
        {
          typename UnvisitedCellMapType::iterator ucit = unvisited_cells.find( cit->id() );
          if (ucit == unvisited_cells.end())
            continue;

          seed_points.push_back( viennagrid::centroid(*cit) );
          unvisited_cells.erase( ucit );

          neighbor_mark( mesh, unvisited_cells );
        }
      }
    }
  }

Foam::tmp<Foam::Field<Type> > Foam::cuttingPlane::sample
(
    const Field<Type>& sf
) const
{
    return tmp<Field<Type> >(new Field<Type>(sf, cells()));
}

void PooledPointTable::reset()
{
    BinaryPointTable table(m_schema);
    pdal::PointRef pointRef(table, 0);

    assert(m_cellNodes.size() >= outstanding());
    Cell::PooledStack cells(m_cellNodes.pop(outstanding()));

    for (auto& cell : cells)
    {
        auto data(m_dataNodes.popOne());
        table.setPoint(*data);

        if (m_origin != invalidOrigin)
        {
            pointRef.setField(pdal::Dimension::Id::PointId, m_index);
            pointRef.setField(pdal::Dimension::Id::OriginId, m_origin);
            ++m_index;
        }

        cell.set(pointRef, std::move(data));
    }

    cells = m_process(std::move(cells));
    for (auto& cell : cells) m_dataNodes.push(cell.acquire());
    m_cellNodes.push(std::move(cells));

    allocate();
}

Cell_Target Targets::cell_target(const Label & label) const
{
    const Target & target = get_target(label);

    // check if target compatible with cells object
    if (target.type() != CELL_TARGET && target.type() != NESTED_TARGET)
    {
        throw Target_Not_Found(
            "Conversion of Target object to Cell_Target object failed. "
            "Target type incompatible with a Neurons object");
    }

    Cell_Target cells(label);
    
    // insert the cell ids of the cell target into cells object
    std::vector<Cell_GID> cell_members;
    target.get_all_gids( cell_members );
    
    for ( unsigned int cellIndex=0; 
        cellIndex < cell_members.size(); cellIndex++ )
    {
        cells.insert( cell_members[cellIndex] );
    }
    
    return cells;
}

int Picker::restoreOpenCategories(const std::list<std::list<std::string> >& idList) {
	int numRestored=0;
	PickerCell *selectedCell = NULL;
	for (std::list<std::list<std::string> >::const_iterator catIt = idList.begin();
		 catIt!=idList.end();
		 ++catIt) {
		PickerCells *celllist = cells();
		for (std::list<std::string>::const_iterator travIt = (*catIt).begin();
			 travIt!=(*catIt).end();
			 ++travIt) {
			PickerCell *cell = celllist->cellWithId((*travIt));
			if (!cell) {
				break;
			}
			celllist = cell->children();
			if (!celllist || celllist->count() == 0) {
				selectedCell = cell;
				break;
			}
			cell->setHideChildren(false);
		}
	}
	
	setMustRecalc();
	if (selectedCell) {
		selectCell(selectedCell, true);
	}
	return numRestored;
}

  long create_mapping(DeviceType const & device,
                      viennashe::unknown_quantity<VertexT> & quantity,
                      long start_index = 0)
  {
    typedef typename DeviceType::mesh_type           MeshType;

    typedef typename viennagrid::result_of::const_cell_range<MeshType>::type      CellContainer;
    typedef typename viennagrid::result_of::iterator<CellContainer>::type         CellIterator;

    //
    // Run the mapping on allowed vertices
    //
    long mapping_index = start_index;

    CellContainer cells(device.mesh());
    for (CellIterator cit = cells.begin();
        cit != cells.end();
        ++cit)
    {
      if ( quantity.get_boundary_type(*cit) != BOUNDARY_DIRICHLET && quantity.get_unknown_mask(*cit) )  // Dirichlet boundary condition
        quantity.set_unknown_index(*cit, mapping_index++);
      else
        quantity.set_unknown_index(*cit, -1);
    }

    return mapping_index;
  } //create_mapping

        int call(std::vector<int> const& v) {
            if (amx && fn) {
                int rezult;
                std::vector<cell> cells(v.size() + 1);

                //precall
                cells[0] = v.size() * sizeof(cell);
                for (std::size_t param_id = 0, len = v.size(); param_id < len; ++param_id) {
                    cell* phys_addr;
                    amx_Allot(amx, 1, &cells[param_id + 1], &phys_addr);
                    *phys_addr = v[param_id];
                }
                //call
                rezult = fn(amx, &cells[0]);

                //postcall
                for (std::size_t param_id = 0, len = v.size(); param_id < len; ++param_id) {
                    amx_Release(amx, cells[param_id + 1]);
                }

                return rezult;
            }
            else {
                assert(false && "error call null amx");
                return -1;
            }
        }

template<class T> cv::Mat minchinton::filter2d(const cv::Mat &data, size_t w) {
    cv::Mat cells(data.size(), CV_8U);

    size_t u = w / 2;
    for (size_t i = 0, m = data.rows; i < m; i++) {
        for (size_t j = 0, n = data.cols; j < n; j++) {
            size_t x = (j < u ? j : j - u);
            size_t y = (i < u ? i : i - u);
            size_t width = (x + w > n ? n - x : w);
            size_t height = (y + w > m ? m - y : w);

            cv::Rect roi(x, y, width, height);
            cv::Mat patch(data, roi);

            cv::Mat mean;
            cv::Mat stdev;
            cv::meanStdDev(patch, mean, stdev);

            T val = data.at<T>(i, j);
            T avg = mean.at<T>(0);
            T std = stdev.at<T>(0);

            cells.at<uchar>(i, j) = (fabs(val - avg) > std ? 255 : 0);
        }
    }

    return cells;
}

int Grid::getNumLiveNeighbors(int x, int y) const
{
    int numLiveNeighbors = 0;

    // Copy of cells with padding so that we don't have to check
    // if the cell is on one of the edges, just check (x-1,y-1) to (x+1,y+1),
    // not including itself (x,y)

    // Create a temp copy of the cells array
    std::vector<std::vector<int>> cells(NUM_CELLS + 2, std::vector<int>(NUM_CELLS + 2, 0));
    for (int i = 0; i < NUM_CELLS; ++i)
    {
        for (int j = 0; j < NUM_CELLS; ++j)
        {
            cells[i+1][j+1] = m_Cells[i][j];
        }
    }

    int offsetX = x + 1;
    int offsetY = y + 1;

    if (cells[offsetX][offsetY-1] == 1) ++numLiveNeighbors;        // North
    if (cells[offsetX+1][offsetY-1] == 1) ++numLiveNeighbors;      // North East
    if (cells[offsetX+1][offsetY] == 1) ++numLiveNeighbors;        // East
    if (cells[offsetX+1][offsetY+1] == 1) ++numLiveNeighbors;      // South East
    if (cells[offsetX][offsetY+1] == 1) ++numLiveNeighbors;        // South
    if (cells[offsetX-1][offsetY+1] == 1) ++numLiveNeighbors;      // South West
    if (cells[offsetX-1][offsetY] == 1) ++numLiveNeighbors;        // West
    if (cells[offsetX-1][offsetY-1] == 1) ++numLiveNeighbors;      // North West

    return numLiveNeighbors;
}

void init_device(DeviceType & device, double voltage)
{
  typedef typename DeviceType::mesh_type           MeshType;

  // STEP 2: Set doping
  std::cout << "* init_device(): Setting doping..." << std::endl;

  device.set_doping_n(1e28);
  device.set_doping_p(1e4);
  device.set_material(viennashe::materials::si());

  typedef typename viennagrid::result_of::const_cell_range<MeshType>::type   CellContainer;

  // STEP 3: Define contacts
  double gnd = 0.0;
  double vcc = voltage;// * 2.0;

  CellContainer cells(device.mesh());

  if (cells.size() < 3) throw std::runtime_error("The Mesh is too small. It contains less than 3 cells!");

  device.set_contact_potential(gnd, cells[0]);
  device.set_material(viennashe::materials::metal(), cells[0]);
  device.set_contact_potential(vcc, cells[cells.size()-1]);
  device.set_material(viennashe::materials::metal(), cells[cells.size()-1]);

}

    void TransportSolverTwophaseReorder::solveGravity(const double* porevolume,
                                                      const double dt,
                                                      TwophaseState& state)
    {
        // Initialize mobilities.
        const int nc = grid_.number_of_cells;
        std::vector<int> cells(nc);
        for (int c = 0; c < nc; ++c) {
            cells[c] = c;
        }
        mob_.resize(2*nc);
        props_.relperm(cells.size(), &state.saturation()[0], &cells[0], &mob_[0], 0);
        const double* mu = props_.viscosity();
        for (int c = 0; c < nc; ++c) {
            mob_[2*c] /= mu[0];
            mob_[2*c + 1] /= mu[1];
        }

        // Set up other variables.
        porevolume_ = porevolume;
        dt_ = dt;
        toWaterSat(state.saturation(), saturation_);

        // Solve on all columns.
        int num_iters = 0;
        for (std::vector<std::vector<int> >::size_type i = 0; i < columns_.size(); i++) {
            // std::cout << "==== new column" << std::endl;
            num_iters += solveGravityColumn(columns_[i]);
        }
        std::cout << "Gauss-Seidel column solver average iterations: "
                  << double(num_iters)/double(columns_.size()) << std::endl;

        toBothSat(saturation_, state.saturation());
    }

long create_mapping(LinPdeSysT & pde_system,
                    std::size_t  pde_index,
                    DomainType const & domain,
                    QuantityContainerT & quantities,
                    long start_index = 0)
{
  typedef typename viennagrid::result_of::cell<DomainType>::type CellTag;

  typedef typename viennagrid::result_of::const_element_range<DomainType, CellTag>::type   CellContainer;
  typedef typename viennagrid::result_of::iterator<CellContainer>::type                    CellIterator;

  typedef typename QuantityContainerT::value_type       QuantityType;

  long map_index = start_index;

  long unknown_id = pde_system.unknown(pde_index)[0].id();

  QuantityType & quan = quantities.at(unknown_id);

  CellContainer cells(domain);
  for (CellIterator cit = cells.begin(); cit != cells.end(); ++cit)
  {
    if (quan.get_unknown_mask(*cit))   // quantity is set to unknown here, so it gets an unknown index assigned
    {
      quan.set_unknown_index(*cit, map_index);
      map_index += pde_system.unknown(pde_index).size();
    }
    else
      quan.set_unknown_index(*cit, -1);
  }

  return map_index;
}