Пример #1
0
void caWaterfallPlot::TimeOut()
{
    // demo curve
    if(thisUnits != Monitor) {
        if(!disableDemo) {
            datamutex->lock();
            GausCurv(position);
            m_data->setData(reducedArray, countRows, ActualNumberOfColumns, getRows(), ActualNumberOfColumns);
            setCols(ActualNumberOfColumns);

            if(firstDemoPlot) {
                updatePlot();
                m_data->setLimits(0., getCols(), 0., getRows(), thisIntensityMin, thisIntensityMax);
                firstDemoPlot = false;
            }

            datamutex->unlock();
            if(drift > 0 && position >= NumberOfColumns) drift = -1;
            if(drift < 0 && position <= 0)  drift = 1;
            position += drift;
        } else {
            if(reducedArray != (double*) 0) {
                datamutex->lock();
                m_data->setData(reducedArray, countRows, ActualNumberOfColumns, getRows(),  ActualNumberOfColumns);
                if(firstTimerPlot) {
                    updatePlot();
                    m_data->setLimits(0., getCols(), 0., getRows(), thisIntensityMin, thisIntensityMax);
                    firstTimerPlot = false;
                }
                datamutex->unlock();
            }
        }
        myReplot();
    }
}
Пример #2
0
//create the cells for the maze
void Maze::createMaze() {
    stack<Cell*> cells;
    
    cells.push(getCell(rand()%getRows(), rand()%getCols()));
       
    while (!cells.empty()) {
	Cell* c1;
	c1 = cells.top();
	cells.pop();
	c1->setVisited();
	vector<direction> neighbors;
        getUnvisitedNeighbors(c1, neighbors);
	if (!neighbors.empty()) {
	    cells.push(c1);
	    int i = rand()%neighbors.size();
	    connect(c1, neighbors.at(i));
	    cells.push(getCell(c1->getRow() + Direction::row(neighbors.at(i)), c1->getCol() + Direction::col(neighbors.at(i))));
	}
    }
    
    setStartCell(getCell(0, rand() % getCols()));
    setEndCell(getCell(getRows()-1, rand() % getCols()));
    
    startCell = getStartCell();
    endCell = getEndCell();
    
}
Пример #3
0
void caWaterfallPlot::updatePlot()
{
    // A color bar on the right axis
/*
    QwtScaleWidget *rightAxis = plot->axisWidget(QwtPlot::yRight);
    rightAxis->setTitle("Intensity");
    rightAxis->setColorBarEnabled(true);
    rightAxis->setColorMap(QwtInterval(thisIntensityMin, thisIntensityMax), new ColorMap_Wavelength());
    plot->setAxisScale(QwtPlot::yRight, thisIntensityMin, thisIntensityMax);
    plot->enableAxis(QwtPlot::yRight);
    thisColormap = spectrum_wavelength;
*/

    // disable labels of left axis
    plot->axisScaleDraw(QwtPlot::yLeft)->enableComponent(QwtAbstractScaleDraw::Labels, false);
    plot->setAxisFont(QwtPlot::xBottom, QFont("Arial", 10));
    plot->setAxisFont(QwtPlot::yLeft, QFont("Arial", 10));

    plot->plotLayout()->setAlignCanvasToScales(true);
    plot->setAxisScale(QwtPlot::xTop, 0, getCols());
    plot->setAxisScale(QwtPlot::xBottom, 0, getCols());
    plot->setAxisMaxMinor(QwtPlot::xTop, 0);
    plot->setAxisScale(QwtPlot::yLeft, getRows(), 0.0);
    plot->setAxisMaxMinor(QwtPlot::yLeft, 0);

    plot->replot();
}
Пример #4
0
bool multiArrayMessageMapToMatrixEigen(MultiArrayMessageType_& m, EigenType_& e)
{
  if (e.IsRowMajor != isRowMajor(m)) {
    ROS_ERROR("multiArrayMessageToMatrixEigen() failed because the storage order is not compatible.");
    return false;
  }

  e.resize(getRows(m), getCols(m));
  e = Eigen::Map<EigenType_>(m.data.data(), getRows(m), getCols(m));
  return true;
}
Пример #5
0
__host__ void gridTransform_(const SrcPtr& src, GpuMat_<DstType>& dst, const UnOp& op, const MaskPtr& mask, Stream& stream = Stream::Null())
{
    const int rows = getRows(src);
    const int cols = getCols(src);

    CV_Assert( getRows(mask) == rows && getCols(mask) == cols );

    dst.create(rows, cols);

    grid_transform_detail::transform<Policy>(shrinkPtr(src), shrinkPtr(dst), op, shrinkPtr(mask), rows, cols, StreamAccessor::getStream(stream));
}
Пример #6
0
__host__ void gridTransform_(const SrcPtr1& src1, const SrcPtr2& src2, GpuMat_<DstType>& dst, const BinOp& op, Stream& stream = Stream::Null())
{
    const int rows = getRows(src1);
    const int cols = getCols(src1);

    CV_Assert( getRows(src2) == rows && getCols(src2) == cols );

    dst.create(rows, cols);

    grid_transform_detail::transform<Policy>(shrinkPtr(src1), shrinkPtr(src2), shrinkPtr(dst), op, WithOutMask(), rows, cols, StreamAccessor::getStream(stream));
}
Пример #7
0
bool multiArrayMessageCopyToMatrixEigen(const MultiArrayMessageType_& m, EigenType_& e)
{
  if (e.IsRowMajor != isRowMajor(m)) {
    ROS_ERROR("multiArrayMessageToMatrixEigen() failed because the storage order is not compatible.");
    return false;
  }

  EigenType_ tempE(getRows(m), getCols(m));
  tempE = Eigen::Map<const EigenType_>(m.data.data(), getRows(m), getCols(m));
  e = tempE;
  return true;
}
Пример #8
0
/*!
   Operator that allows to substract two row vectors that have the same size.
   \exception vpException::dimensionError If the size of the two vectors differ.
 */
vpRowVector &
vpRowVector::operator-=(vpRowVector v)
{
  if (getCols() != v.getCols() ) {
    throw(vpException(vpException::dimensionError,
                      "Cannot substract (1x%d) row vector to (1x%d) row vector",
                      getCols(), v.getCols())) ;
  }

  for (unsigned int i=0;i<colNum;i++)
    (*this)[i] -= v[i];
  return (*this);
}
Пример #9
0
/*!
   Operator that allows to add to row vectors that have the same size.
   \exception vpException::dimensionError If the vectors size differ.
 */
vpRowVector vpRowVector::operator+(const vpRowVector &v) const
{
  if (getCols() != v.getCols() ) {
    throw(vpException(vpException::dimensionError,
                      "Cannot add (1x%d) row vector to (1x%d) row vector",
                      getCols(), v.getCols())) ;
  }

  vpRowVector r(colNum) ;

  for (unsigned int i=0;i<colNum;i++)
    r[i] = (*this)[i] + v[i];
  return r;
}
Пример #10
0
/*!
   Operator that allows to substract to row vectors that have the same size.
   \exception vpException::dimensionError If the vectors size differ.
 */
vpRowVector vpRowVector::operator-(const vpRowVector &m) const
{
  if (getCols() != m.getCols() ) {
    throw(vpException(vpException::dimensionError,
                      "Cannot substract (1x%d) row vector to (1x%d) row vector",
                      getCols(), m.getCols())) ;
  }

  vpRowVector v(colNum) ;

  for (unsigned int i=0;i<colNum;i++)
    v[i] = (*this)[i] - m[i];
  return v;
}
Пример #11
0
__host__ ZipPtrSz< tuple<typename PtrTraits<Ptr0>::ptr_type, typename PtrTraits<Ptr1>::ptr_type> >
zipPtr(const Ptr0& ptr0, const Ptr1& ptr1)
{
    const int rows = getRows(ptr0);
    const int cols = getCols(ptr0);

    CV_Assert( getRows(ptr1) == rows && getCols(ptr1) == cols );

    ZipPtrSz< tuple<typename PtrTraits<Ptr0>::ptr_type, typename PtrTraits<Ptr1>::ptr_type> >
            z(make_tuple(shrinkPtr(ptr0), shrinkPtr(ptr1)));
    z.rows = rows;
    z.cols = cols;

    return z;
}
Пример #12
0
__host__ RemapPtr2Sz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<MapXPtr>::ptr_type, typename PtrTraits<MapYPtr>::ptr_type>
remapPtr(const SrcPtr& src, const MapXPtr& mapx, const MapYPtr& mapy)
{
    const int rows = getRows(mapx);
    const int cols = getCols(mapx);

    CV_Assert( getRows(mapy) == rows && getCols(mapy) == cols );

    RemapPtr2Sz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<MapXPtr>::ptr_type, typename PtrTraits<MapYPtr>::ptr_type> r;
    r.src = shrinkPtr(src);
    r.mapx = shrinkPtr(mapx);
    r.mapy = shrinkPtr(mapy);
    r.rows = rows;
    r.cols = cols;
    return r;
}
Пример #13
0
__host__ void gridFindMaxVal_(const SrcPtr& src, GpuMat_<ResType>& dst, const MaskPtr& mask, Stream& stream = Stream::Null())
{
    dst.create(1, 1);
    dst.setTo(Scalar::all(-std::numeric_limits<ResType>::max()), stream);

    const int rows = getRows(src);
    const int cols = getCols(src);

    CV_Assert( getRows(mask) == rows && getCols(mask) == cols );

    grid_reduce_detail::maxVal<Policy>(shrinkPtr(src),
                                       dst[0],
                                       shrinkPtr(mask),
                                       rows, cols,
                                       StreamAccessor::getStream(stream));
}
Пример #14
0
 // << inserts character c at the current cursor position
 //
 BConsole& BConsole::putChar(char c) {
   if(curRow>=0 && curCol >=0 && curRow < getRows() && curCol < getCols() ){ // prints the character only if it is on screen
     ::putch(c);
     setBufChar(c);
   }
   return *this;
 }
Пример #15
0
bool String::operator==(const InternalType& it)
{
    if (const_cast<InternalType&>(it).isString() == false)
    {
        return false;
    }

    String* pS = const_cast<InternalType&>(it).getAs<types::String>();

    if (pS->getRows() != getRows() || pS->getCols() != getCols())
    {
        return false;
    }

    wchar_t **p1 = get();
    wchar_t **p2 = pS->get();

    for (int i = 0 ; i < getSize() ; i++)
    {
        if (wcscmp(p1[i], p2[i]) != 0)
        {
            return false;
        }
    }
    return true;
}
Пример #16
0
__host__ BinaryTransformPtrSz<typename PtrTraits<Src1Ptr>::ptr_type, typename PtrTraits<Src2Ptr>::ptr_type, Op>
transformPtr(const Src1Ptr& src1, const Src2Ptr& src2, const Op& op)
{
    const int rows = getRows(src1);
    const int cols = getCols(src1);

    CV_Assert( getRows(src2) == rows && getCols(src2) == cols );

    BinaryTransformPtrSz<typename PtrTraits<Src1Ptr>::ptr_type, typename PtrTraits<Src2Ptr>::ptr_type, Op> ptr;
    ptr.src1 = shrinkPtr(src1);
    ptr.src2 = shrinkPtr(src2);
    ptr.op = op;
    ptr.rows = rows;
    ptr.cols = cols;
    return ptr;
}
Пример #17
0
/*
 *  Method used to test a maze to make sure all cells
 *  have been visited.
 *  
 */
bool Maze::allCellsVisited() const {
    for (int r=0; r < getRows(); r++) {
        for (int c=0; c < getCols(); c++) {
            if (!getCell(r,c)->isVisited()) return false;
        }
    }
    return true;
}
Пример #18
0
bool Cell::isEmpty()
{
    if (getDims() == 2 && getRows() == 0 && getCols() == 0)
    {
        return true;
    }
    return false;
}
Пример #19
0
Cell* Cell::set(int _iRows, int _iCols, const InternalType* _pIT)
{
    if (_iRows < getRows() && _iCols < getCols())
    {
        return set(_iCols * getRows() + _iRows, _pIT);
    }
    return NULL;
}
Пример #20
0
__host__ BrdBase<BrdWrap, typename PtrTraits<SrcPtr>::ptr_type> brdWrap(const SrcPtr& src)
{
    BrdBase<BrdWrap, typename PtrTraits<SrcPtr>::ptr_type> b;
    b.src = shrinkPtr(src);
    b.rows = getRows(src);
    b.cols = getCols(src);
    return b;
}
Пример #21
0
__host__ DerivXPtrSz<typename PtrTraits<SrcPtr>::ptr_type> derivXPtr(const SrcPtr& src)
{
    DerivXPtrSz<typename PtrTraits<SrcPtr>::ptr_type> s;
    s.src = shrinkPtr(src);
    s.rows = getRows(src);
    s.cols = getCols(src);
    return s;
}
Пример #22
0
__host__ LaplacianPtrSz<ksize, typename PtrTraits<SrcPtr>::ptr_type> laplacianPtr(const SrcPtr& src)
{
    LaplacianPtrSz<ksize, typename PtrTraits<SrcPtr>::ptr_type> ptr;
    ptr.src = shrinkPtr(src);
    ptr.rows = getRows(src);
    ptr.cols = getCols(src);
    return ptr;
}
Пример #23
0
__host__ void gridPyrUp(const SrcPtr& src, GpuMat_<DstType>& dst, Stream& stream = Stream::Null())
{
    const int rows = getRows(src);
    const int cols = getCols(src);

    dst.create(rows * 2, cols * 2);

    pyramids_detail::pyrUp(shrinkPtr(src), shrinkPtr(dst), rows, cols, dst.rows, dst.cols, StreamAccessor::getStream(stream));
}
Пример #24
0
__host__ BrdConstant<typename PtrTraits<SrcPtr>::ptr_type> brdConstant(const SrcPtr& src, typename PtrTraits<SrcPtr>::value_type val)
{
    BrdConstant<typename PtrTraits<SrcPtr>::ptr_type> b;
    b.src = shrinkPtr(src);
    b.rows = getRows(src);
    b.cols = getCols(src);
    b.val = val;
    return b;
}
Пример #25
0
__host__ void gridHistogram_(const SrcPtr& src, GpuMat_<ResType>& dst, const MaskPtr& mask, Stream& stream = Stream::Null())
{
    CV_Assert( deviceSupports(SHARED_ATOMICS) );

    const int rows = getRows(src);
    const int cols = getCols(src);

    CV_Assert( getRows(mask) == rows && getCols(mask) == cols );

    dst.create(1, BIN_COUNT);
    dst.setTo(0, stream);

    grid_histogram_detail::histogram<BIN_COUNT, Policy>(shrinkPtr(src),
                                                        dst[0],
                                                        shrinkPtr(mask),
                                                        rows, cols,
                                                        StreamAccessor::getStream(stream));
}
Пример #26
0
//
// Recursively generate mangled names.
//
TString TType::buildMangledName() const
{
    TString mangledName;
    if (isMatrix())
        mangledName += 'm';
    else if (isVector())
        mangledName += 'v';

    switch (type)
    {
      case EbtFloat:                mangledName += 'f';      break;
      case EbtInt:                  mangledName += 'i';      break;
      case EbtUInt:                 mangledName += 'u';      break;
      case EbtBool:                 mangledName += 'b';      break;
      case EbtSampler2D:            mangledName += "s2";     break;
      case EbtSampler3D:            mangledName += "s3";     break;
      case EbtSamplerCube:          mangledName += "sC";     break;
      case EbtSampler2DArray:       mangledName += "s2a";    break;
      case EbtSamplerExternalOES:   mangledName += "sext";   break;
      case EbtSampler2DRect:        mangledName += "s2r";    break;
      case EbtISampler2D:           mangledName += "is2";    break;
      case EbtISampler3D:           mangledName += "is3";    break;
      case EbtISamplerCube:         mangledName += "isC";    break;
      case EbtISampler2DArray:      mangledName += "is2a";   break;
      case EbtUSampler2D:           mangledName += "us2";    break;
      case EbtUSampler3D:           mangledName += "us3";    break;
      case EbtUSamplerCube:         mangledName += "usC";    break;
      case EbtUSampler2DArray:      mangledName += "us2a";   break;
      case EbtSampler2DShadow:      mangledName += "s2s";    break;
      case EbtSamplerCubeShadow:    mangledName += "sCs";    break;
      case EbtSampler2DArrayShadow: mangledName += "s2as";   break;
      case EbtStruct:               mangledName += structure->mangledName(); break;
      case EbtInterfaceBlock:       mangledName += interfaceBlock->mangledName(); break;
      default:                      UNREACHABLE();
    }

    if (isMatrix())
    {
        mangledName += static_cast<char>('0' + getCols());
        mangledName += static_cast<char>('x');
        mangledName += static_cast<char>('0' + getRows());
    }
    else
    {
        mangledName += static_cast<char>('0' + getNominalSize());
    }

    if (isArray()) {
        char buf[20];
        snprintf(buf, sizeof(buf), "%d", arraySize);
        mangledName += '[';
        mangledName += buf;
        mangledName += ']';
    }
    return mangledName;
}
Пример #27
0
__host__ void gridMinMaxLoc_(const SrcPtr& src, GpuMat_<ResType>& valBuf, GpuMat_<int>& locBuf, const MaskPtr& mask, Stream& stream = Stream::Null())
{
    const int rows = getRows(src);
    const int cols = getCols(src);

    CV_Assert( getRows(mask) == rows && getCols(mask) == cols );

    dim3 grid, block;
    grid_minmaxloc_detail::getLaunchCfg<Policy>(rows, cols, block, grid);

    valBuf.create(2, grid.x * grid.y);
    locBuf.create(2, grid.x * grid.y);

    grid_minmaxloc_detail::minMaxLoc<Policy>(shrinkPtr(src),
                                             valBuf[0], valBuf[1], locBuf[0], locBuf[1],
                                             shrinkPtr(mask),
                                             rows, cols,
                                             StreamAccessor::getStream(stream));
}
Пример #28
0
double RMatrix::getUniformScaleFactor() const {
    if (getRows()!=2 || getCols()!=2) {
        return RNANDOUBLE;
    }
    double a = getRotationAngle();
    if (RMath::isNaN(a)) {
        return RNANDOUBLE;
    }
    return get(0,0) / cos(a);
}
Пример #29
0
RVector RMatrix::multiplyWith(const RVector& v) const {
    if (getRows()==2 && getCols()==2) {
        return RVector(
            get(0,0)*v.x + get(0,1)*v.y,
            get(1,0)*v.x + get(1,1)*v.y
        );
    }

    return RVector::invalid;
}
Пример #30
0
__host__ void gridTransform_(const SrcPtr& src, const tuple< GpuMat_<D0>&, GpuMat_<D1>& >& dst, const OpTuple& op, const MaskPtr& mask, Stream& stream = Stream::Null())
{
    CV_StaticAssert( tuple_size<OpTuple>::value == 2, "" );

    const int rows = getRows(src);
    const int cols = getCols(src);

    CV_Assert( getRows(mask) == rows && getCols(mask) == cols );

    get<0>(dst).create(rows, cols);
    get<1>(dst).create(rows, cols);

    grid_transform_detail::transform_tuple<Policy>(shrinkPtr(src),
                                                   shrinkPtr(zipPtr(get<0>(dst), get<1>(dst))),
                                                   op,
                                                   shrinkPtr(mask),
                                                   rows, cols,
                                                   StreamAccessor::getStream(stream));
}