예제 #1
0
void getExpShift(const Array2D8u& img1, const int median1,
                 const Array2D8u& img2, const int median2,
                 const int noise, const int shift_bits,
                 int &shift_x, int &shift_y)
{
    assert(img1.getCols() == img2.getCols());
    assert(img1.getRows() == img2.getRows());

    int curr_x = 0;
    int curr_y = 0;

    if (shift_bits > 0)
    {
        Array2D8u img1small(img1.getCols()/2, img1.getRows()/2);
        Array2D8u img2small(img2.getCols()/2, img2.getRows()/2);

        pfs::resize(img1, img1small);
        pfs::resize(img2, img2small);

        getExpShift(img1small, median1, img2small, median2,
                    noise, shift_bits-1, curr_x, curr_y);
        curr_x *= 2;
        curr_y *= 2;
    }

    Array2Db img1threshold(img1.getCols(), img1.getRows());
    Array2Db img1mask(img1.getCols(), img1.getRows());
    Array2Db img2threshold(img2.getCols(), img2.getRows());
    Array2Db img2mask(img2.getCols(), img2.getRows());

    setThreshold(img1, median1, noise, img1threshold, img1mask);
    setThreshold(img2, median2, noise, img2threshold, img2mask);

    Array2Db img2_shifted(img2.getCols(), img2.getRows());
    Array2Db img2mask_shifted(img2.getCols(), img2.getRows());

    int minerr = img1.size();
    for (int i = -1; i <= 1; i++)
    {
        for (int j = -1; j <= 1; j++)
        {
            int dx = curr_x + i;
            int dy = curr_y + j;

            pfs::shift(img2threshold, dx, dy, img2_shifted);
            pfs::shift(img2mask, dx, dy, img2mask_shifted);

            long err = XORimages(img1threshold, img1mask, img2_shifted, img2mask_shifted);

            if ( err < minerr ) {
                minerr = err;
                shift_x = dx;
                shift_y = dy;
            }
        }
    }

    PRINT_DEBUG("getExpShift::Level " << shift_bits	<< " shift (" << shift_x << "," << shift_y << ")");
}
예제 #2
0
//--------------------------------------------------------------
ofxUIMovingGraphThreshold::ofxUIMovingGraphThreshold(float w, float h, vector<float> _buffer, int _bufferSize, float _min, float _max, string _name)
: ofxUIMovingGraph(w,h,_buffer,_bufferSize,_min,_max,_name)
{
	setThreshold(0.0f);
	m_value = 0.0f;
	setState("");
}
예제 #3
0
파일: Phone.cpp 프로젝트: TylerOderkirk/ihu
void Phone::setup(int mode, int quality, int abr, int vbr, float vbr_quality, int complexity, int vad, int dtx, int txstop, int th, int ring_vol)
{
	bool restart = recording;
	if (restart)
		stopRecorder();

	if (enc_state)
		speex_encoder_destroy(enc_state);

	SpeexMode *spmode = NULL;
	
	switch (mode)
	{
		case IHU_NARROW:
			spmode = (SpeexMode *) &speex_nb_mode;
			break;
		case IHU_WIDE:
			spmode = (SpeexMode *) &speex_wb_mode;
			break;
		case IHU_ULTRAWIDE:
			spmode = (SpeexMode *) &speex_uwb_mode;
			break;
	}
	
	enc_state = speex_encoder_init(spmode);

	speex_encoder_ctl(enc_state, SPEEX_SET_COMPLEXITY, &complexity);
	if (vbr)
	{
		speex_encoder_ctl(enc_state, SPEEX_SET_VBR, &vbr);
		speex_encoder_ctl(enc_state, SPEEX_SET_VBR_QUALITY, &vbr_quality);
	}
	else
	{
		speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &quality);
		speex_encoder_ctl(enc_state, SPEEX_SET_VAD, &vad);
	}
	if (abr)
		speex_encoder_ctl(enc_state, SPEEX_SET_ABR, &abr);
	speex_encoder_ctl(enc_state, SPEEX_SET_DTX, &dtx);
	
	speex_encoder_ctl(enc_state, SPEEX_GET_SAMPLING_RATE, &rate);
	speex_encoder_ctl(enc_state, SPEEX_GET_FRAME_SIZE, &frame_size);

	stoptx = txstop;
	
	speex_bits_init(&enc_bits);
	
	ring_vol = -ring_vol + 1;
	float vol = 0.0;
	if (ring_vol <= 0)
		vol = powf(VOL_FACTOR, (float) (ring_vol));
	for (int i=0; i<SIZE_RING_32; i++)
		ringBuffer[i] = ((float) ring_32[i]) * vol;

	setThreshold(th);

	if (restart)
		startRecorder();
}
예제 #4
0
Graph& Graph::setup(string name, float threshold) {
	setName(name);
	if(threshold > 0) {
		setThreshold(threshold);
	}
	return *this;
}
예제 #5
0
bool Meter::isMouseOnMeter(int x, int y){
    if(x<thresholdBarLoc.x+thresholdBarSize.x&&x>thresholdBarLoc.x&&y>thresholdBarLoc.y&&y<thresholdBarLoc.y+thresholdBarSize.y){
        cout<<"CLICK"<<endl;
        float value = 1.f-(y-thresholdBarLoc.y)/thresholdBarSize.y;
        cout << value<<endl;
        setThreshold(value);
    }
}
예제 #6
0
//thresholds all images (glove2 needs all colors thresholded)
void Detector::thresholdForGlove2(Mat src) {

    setThreshold('b');
    blueThreshImg = segmentFrame(src);

    setThreshold('g');
    greenThreshImg = segmentFrame(src);

    setThreshold('p');
    pinkThreshImg = segmentFrame(src);

    setThreshold('r');
    redThreshImg = segmentFrame(src);

    setThreshold('y');
    yellowThreshImg = segmentFrame(src);
}
예제 #7
0
void BinaryOutputElement::initBOR(int inputs, Align a, double threshold, ThresholdType tt)
{
	intRect = boundingRect().adjusted(5, 5, -5, -5);
	setAligment(a);
	setInputSize(inputs);
	setThresholdType(tt);
	setThreshold(threshold);
}
예제 #8
0
 OMPLGoalState::OMPLGoalState(const ob::SpaceInformationPtr &si,
     OMPLProblem_ptr prob)
     : ob::GoalState(si), prob_(prob)
 {
   type_ = ob::GOAL_STATE;
   state_space_ = si->getStateSpace();
   setThreshold(std::numeric_limits<double>::epsilon());
 }
void NonGradient::initialize_mesh_iteration(PatchData &pd, MsqError &err)
{
  int elementDimension = getPatchDimension( pd, err );  // to do: react to error
  int dimension = elementDimension * pd.num_free_vertices();
  //printPatch( pd, err );
  setDimension(dimension);
  int maxNumEval = 100*dimension;  // 1. Make this a user parameter
  setMaxNumEval(maxNumEval);
  double threshold = 1.e-10; // avoid division by zero
  setThreshold(threshold);
  double minEdgeLen = 0.0;
  double maxEdgeLen = 0.0;
//  double ftol = 0.;
  if( dimension > 0 )
  {
    pd.get_minmax_edge_length( minEdgeLen, maxEdgeLen );
    //ftol = minEdgeLen * 1.e-4; // Turn off Amoeba convergence criterion
    if( mNonGradDebug >= 1 ) 
    {      
         std::cout << "minimum edge length " << minEdgeLen << " maximum edge length " << maxEdgeLen << std::endl;
    }      
    MSQ_PRINT(3)("minimum edge length %e    maximum edge length %e\n", minEdgeLen,  maxEdgeLen);
  }
//  setTolerance(ftol);
  int numRow = dimension;
  int numCol = numRow+1;  
  if( numRow*numCol <= simplex.max_size() )
  { 
    simplex.assign(numRow*numCol, 0.);  // guard against previous simplex value
    double scale = minEdgeLen * mScaleDiameter;; 
    const MsqVertex* coord = pd.get_vertex_array(err);
    if( pd.num_free_vertices() > 1 )
    {
      MSQ_SETERR(err)("Only one free vertex per patch implemented", MsqError::NOT_IMPLEMENTED);
    }
    size_t index = 0;
    for( int col = 0; col < numCol; col++ )
    {
      for (int row=0;row<numRow;row++)
      {
        simplex[ row + col*numRow ] = coord[index][row];
        if( row == col-1 )
        {
          simplex[ row + col*numRow ] += scale/ static_cast<double>(numCol);
        }
      }
    }
  }
  else
  {
    MSQ_SETERR(err)("Use patch with fewer free vertices", MsqError::OUT_OF_MEMORY);
    if( mNonGradDebug >= 1 ) 
    {      
      std::cout << "ERROR: Too many free vertices in patch" << std::endl;
    }      
    //MSQ_PRINT(1)("ERROR: Too many free vertices in patch\n");
  }
}
예제 #10
0
ARTracker::ARTracker(DebugMode debugMode, int threshold, bool blurring){
    setDebugMode(debugMode);
    setThreshold(threshold);
    setBlurring(blurring);
    
    initPerspectiveTransformTarget();
    initModelPoints();
    
}
void ThresholdBar::updateGUI(){
    if ( ofGetMousePressed() ){
        float mouseX = ofGetMouseX();
        float mouseY = ofGetMouseY();
        
        if ((mouseX >= x ) && 
            (mouseX <= x + width) &&
            (mouseY >= y ) && 
            (mouseY <= y + height)){
            
            if ( !vertOriented ){
                setThreshold( (mouseX - x) / width );
            } else {
                setThreshold( 1.0 - ((mouseY - y) / height) );
            }
        }
    }
};
예제 #12
0
void Normalization::init(Normalization::Type nt, double max, double min, double threshold, double amp, double elong)
{
	setType(nt);
	setMaxValue(max);
	setMinValue(min);
	setThreshold(threshold);
	setAmplitude(amp);
	setElongation(elong);
}
예제 #13
0
void Adaline::setInputSize(int n)
{
	if(n != (int) weights.size()){
		setWeights(getRandomValues((int)n));
		setThreshold(getRandomValues(1)[0]);
	}else{
		qWarning("No se realizo cambio alguno porque el numero de entradas no vario");
	}
}
예제 #14
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Watershed::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
  reader->openFilterGroup(this, index);
  setSelectedCellArrayPath( reader->readDataArrayPath( "SelectedCellArrayPath", getSelectedCellArrayPath() ) );
  setFeatureIdsArrayName( reader->readString( "FeatureIdsArrayName", getFeatureIdsArrayName() ) );
  setThreshold( reader->readValue( "Threshold", getThreshold() ) );
  setLevel( reader->readValue( "Level", getLevel() ) );
  reader->closeFilterGroup();
}
예제 #15
0
/*** PRIVATE SLOTS ***/
void ScoreDistribution::selected(const QPointF &point)
{
    if ((qpmMarker.xValue() == point.x()) ||
        (qpcLive.data()->size() <= 1))
        return;

    setThreshold(point.x());
    emit newThreshold(point.x());
}
예제 #16
0
LimiterImpl::LimiterImpl(int sampleRate) {

    sampleRate = MAX(sampleRate, 8000);
    sampleRate = MIN(sampleRate, 96000);
    _sampleRate = sampleRate;

    // defaults
    setThreshold(0.0f);
    setRelease(250.0f);
}
bool ExecutionCounter::checkIfThresholdCrossedAndSet(CodeBlock* codeBlock)
{
    if (hasCrossedThreshold(codeBlock))
        return true;
    
    if (setThreshold(codeBlock))
        return true;
    
    return false;
}
void ChromaCommand::readProperties(boost::property_tree::wptree& pt)
{
    AbstractCommand::readProperties(pt);

    if (pt.count(L"chromablur") > 0)        setSpread(pt.get<float>(L"chromablur"));
    if (pt.count(L"chromakey") > 0)         setKey(QString::fromStdWString(pt.get<std::wstring>(L"chromakey")));
    if (pt.count(L"chromasoftness") > 0)    setSpread(pt.get<float>(L"chromasoftness"));
    if (pt.count(L"chromaspill") > 0)       setSpill(pt.get<float>(L"chromaspill"));
    if (pt.count(L"chromathreshold") > 0)   setThreshold(pt.get<float>(L"chromathreshold"));
    setShowMask(false);
}
예제 #19
0
//virtual
void ColorDetector::onValueChanged(QtProperty* property,
								   void* id,
								   const QVariant& variant)
{
	// addIntProperty(tr("Threshold"), m_threshold, 0, 1000);
	// addColorProperty(tr("Target Color"), m_targetColor.toQColor());
	if (id == m_threshold.id()) {
		setThreshold(variant.value<int>());
	} else if (id == m_targetColor.id()) {
		setTargetColor(variant.value<QColor>());
	}
}
예제 #20
0
void Adaline::init(const vector<double> &weights, TransferFunctionType tf)
{
	size_t sWeights = weights.size();
	if(sWeights > 0){
		setWeights(weights);
		setAlfa(1);
		setThreshold(getRandomValues(1)[0]);
		setTransferFunction(tf);
	}else{
		qWarning() << "Se debe asignar al menos una entrada a un perceptron simple";
	}
}
예제 #21
0
void Compressor::setNValue(int idx, double value)
      {
      switch (idx) {
            case RMS_PEAK:  setRmsPeak(value);    break;
            case ATTACK:    setAttack(value);     break;
            case RELEASE:   setRelease(value);    break;
            case THRESHOLD: setThreshold(value);  break;
            case RATIO:     setRatio(value);      break;
            case KNEE:      setKnee(value);       break;
            case GAIN:      setMakeupGain(value); break;
            }
      }
예제 #22
0
Normalization &Normalization::operator=(const Normalization &nor)
{
	if(this != &nor){
		setMaxValue(nor.getMaxValue());
		setMinValue(nor.getMinValue());
		setThreshold(nor.getThreshold());
		setType(nor.getType());
		setAmplitude(nor.getAmplitude());
		setElongation(nor.getElongation());
	}
	return *this;
}
예제 #23
0
//------------------------------------------------------------------------------
// setSlotThreshold() -- converts a power to watts and sets our antenna threshold
//------------------------------------------------------------------------------
bool Antenna::setSlotThreshold(Basic::Power* const p)
{
    bool ok = false;
    // Has power units and we need watts
    Basic::Watts watts;
    double x = watts.convert(*p);
    
    // Test and set the threshold
    if (x >= 0.0) ok = setThreshold(x);

    return ok;
}
예제 #24
0
void SetupSinal::setRFData(Matrix rf)
{
  rfdata = rf;
  env = rfdata;
  time_cut = rfdata;

  //para garantir que o valor do vetor de limiar seja do mesmo tamanho do sinal
  limiar = rfdata;
  setThreshold(v_limiar);

  imgproc.hilbert(env);
  env_gain = env;
}
예제 #25
0
static void  setConfig(void* self, const char* name, const char* value)
{
   PODConfigurationElement*    cfgElement;


    /*
     * Find the named item.
     */
    for (cfgElement = this->mConfig; cfgElement->name != NULL; cfgElement++)
    {
        if (strcmp(name, cfgElement->name) == 0)
        {
            break;
        }
    }

    /*
     * Cant set that which does not exist!
     */
    if ( !cfgElement->name )
    {
        return;
    }

    /*
     * OK time to do some work...
     */
    if (strcmp(name, CFG_STATUS) == 0)
    {
        if (strcmp(value, CFG_ACTION_ENABLE) == 0)
        {
            talpa_mutex_lock(&this->mConfigSerialize);
            enable(this);
            talpa_mutex_unlock(&this->mConfigSerialize);
        }
        else if (strcmp(value, CFG_ACTION_DISABLE) == 0)
        {
            talpa_mutex_lock(&this->mConfigSerialize);
            disable(this);
            talpa_mutex_unlock(&this->mConfigSerialize);
        }
    }
    else if ( !strcmp(name, CFG_THRESHOLD) )
    {
        talpa_mutex_lock(&this->mConfigSerialize);
        setThreshold(this, value);
        talpa_mutex_unlock(&this->mConfigSerialize);
    }

    return;
}
예제 #26
0
// setSlotThreshold() - Sets Signal to Noise Threshold
bool IrSensor::setSlotThreshold(const base::Number* const msg)
{
   bool ok = false;
   if (msg != nullptr) {
      double x = msg->getReal();
      ok = setThreshold(x);
      if (!ok) {
         if (isMessageEnabled(MSG_ERROR)) {
            std::cerr << "IrSensor::setSlotThreshold: Error setting Signal to Noise Threshold!" << std::endl;
         }
      }
   }
   return ok;
}
예제 #27
0
void IndicatorLight::loadSettings(QSettings &settings) {
    PanelItem::loadSettings(settings);

    setDataRefName(settings.value("datarefname","sim/cockpit/misc/compass_indicated").toString());
    setThreshold(settings.value("threshold","0.1").toDouble());
    setStrengthOn(settings.value("strengthon","100").toInt());
    setStrengthOff(settings.value("strengthoff","20").toInt());
    setLabelOn(settings.value("labelon","BRAKES").toString());
    setLabelOff(settings.value("labeloff","BRAKES").toString());
    setLabelColor(QColor(settings.value("labelcolor","red").toString()));
    setGlowStrength(settings.value("glowstrength","80").toInt());

    DEBUG << _datarefName;
}
	virtual bool init() {
		// Work with luminance images
		setPixelFormat(ARToolKitPlus::PIXEL_FORMAT_LUM);
		if ( ! checkPixelFormat()) {	
			if (logger)
				logger->artLog("ARToolKitPlus: Invalid Pixel Format!");
			return false;
		}

		// Memory
		if (marker_infoTWO == NULL)
			marker_infoTWO = ARToolKitPlus::artkp_Alloc<ARToolKitPlus::ARMarkerInfo2>(32);

		// Camera
		Camera *camera = new Camera(screenWidth, screenHeight);
		setCamera(camera, 1, 1000);

		// const ARFloat* mat = getProjectionMatrix();
		// printf("Proj mat\n");
		// for(int j=0; j<4; j++) {
		// 	for(int i=0; i<4; i++) {
		// 		printf ("%f, ", mat[i*4 + j]);
		// 	}
		// 	printf ("\n");
		// }

		// Work at full res
		setImageProcessingMode(ARToolKitPlus::IMAGE_FULL_RES);

		// Set border
		setBorderWidth(0.125);

		// Set threshold and activate automatic threshold
		setThreshold(160);
		activateAutoThreshold(true);
		setNumAutoThresholdRetries(2);

		// Switch to BCH ID based markers
		setMarkerMode(ARToolKitPlus::MARKER_ID_BCH);

		// Choose pose estimator
		setPoseEstimator(ARToolKitPlus::
						 //POSE_ESTIMATOR_ORIGINAL);
						 //POSE_ESTIMATOR_ORIGINAL_CONT);
						 POSE_ESTIMATOR_RPP);

		return true;
	}
예제 #29
0
void IndicatorDisplay::loadSettings(QSettings &settings) {
    PanelItem::loadSettings(settings);

    setDataRefName(settings.value("datarefname","sim/cockpit/misc/compass_indicated").toString());
    setThreshold(settings.value("threshold","0.1").toDouble());
    setStrengthOn(settings.value("strengthon","100").toInt());
    setStrengthOff(settings.value("strengthoff","20").toInt());
    setLabelOn(settings.value("labelon","BRAKES").toString());
    setLabelOff(settings.value("labeloff","BRAKES").toString());
    setLabelColor(QColor(settings.value("labelcolor","white").toString()));
    setValueColor(QColor(settings.value("valuecolor","white").toString()));
    setShowValue(settings.value("showvalue","false").toString()=="true");
    setValueDivisor(settings.value("valuedivisor","1").toInt());

    DEBUG << _datarefName;
}
예제 #30
0
QPoint RedEyeDetection::locateStartingPoint(const QImage &image,
					    const QRect &rect) const
{
    // Find optimal starting point (one with highest red value
    // relative to green and blue)

    const int coeflen = 6;
    const int coefs[13] = {28, 39, 48, 55, 60, 63, 64,
			   63, 60, 55, 48, 39, 28}; // 8*8 - {0,1,2...}^2

    QPoint centerMax = QPoint();
    int redMax = 0, redRatio = 0;

    // The center point is set in full-image coordinates

    setThreshold(0);

    int x_c = rect.center().x();
    int y_c = rect.center().y();
    int d_max = qMax(rect.width()/2, rect.height()/2);

    for (int y=rect.top(); y<=rect.bottom(); y++)
    {
	int y_coef = coefs[(coeflen*(y-y_c))/d_max + coeflen];
	for (int x=rect.left(); x <= rect.right(); x++)
	{
	    QRgb rgb = image.pixel(QPoint(x, y));

	    if (isRedEyePixel(rgb))
	    {
		redRatio = qRed(rgb) * 255 /
			   (qRed(rgb) + qGreen(rgb) + qBlue(rgb));

		int x_coef = coefs[(coeflen*(x-x_c))/d_max + coeflen];
		redRatio *= x_coef + y_coef;

		if (redRatio > redMax) {
		    redMax = redRatio;
		    centerMax = QPoint(x, y);
		}
	    }
	}
    }

    return centerMax;
}