Ejemplo n.º 1
0
static void computeOffset(cv::Mat img1, cv::Mat img2, int d, cv::Point& _off)
{
  cv::Point offset;
  cv::Size size1 = img1.size(), size2 = img2.size();
  
  if ((size1.width > 2 && size1.height > 2) &&
      (size2.width > 2 && size2.height > 2) &&
      (d < 16)) {
    cv::Mat tmp1, tmp2;
    cv::resize(img1, tmp1, cv::Size(), 0.5f, 0.5f);
    cv::resize(img2, tmp2, cv::Size(), 0.5f, 0.5f);
    computeOffset(tmp1, tmp2, d+1, offset);
    offset.x *= 2, offset.y *= 2;
  } else {
    offset.x = 0, offset.y = 0;
  }
  
  cv::Point result;
  cv::Mat tb1, tb2, eb1, eb2;
  computeBitmaps(img1, tb1, eb1);
  computeBitmaps(img2, tb2, eb2);
  
  cv::Rect bound1(cv::Point(0,0), size1);
  cv::Rect bound2(cv::Point(0,0), size2);
  
  int min_err = (bound1 & bound2).area();
  
  for (int dx = -1; dx <= 1; ++dx) {
    for (int dy = -1; dy <= 1; ++dy) {
      cv::Point displace = offset + cv::Point(dx,dy);
      cv::Rect frame = bound1 & (bound2 + displace);
      cv::Rect shift = bound2 & (bound1 - displace);
      
      // ROIs
      cv::Mat framed_tb1(tb1, frame);
      cv::Mat framed_eb1(eb1, frame);
      cv::Mat shifted_tb2(tb2, shift);
      cv::Mat shifted_eb2(eb2, shift);
      
      //
      cv::Mat tmp1, tmp2;
      cv::bitwise_xor(framed_tb1, shifted_tb2, tmp1);
      cv::bitwise_and(tmp1, framed_eb1, tmp2);
      cv::bitwise_and(shifted_eb2, tmp2, tmp1);
      
      //
      int err = (int)cv::sum(tmp1)[0];
      if (dx == 0 && dy == 0)
        err -= 1;
      if (err < min_err) {
        result = displace;
        min_err = err;
      }
    }
  }
  
  _off = result;
}
typename TreeType::ElemType MinimalCoverageSweep<SplitPolicy>::
SweepLeafNode(const size_t axis,
              const TreeType* node,
              typename TreeType::ElemType& axisCut)
{
  typedef typename TreeType::ElemType ElemType;
  typedef bound::HRectBound<metric::EuclideanDistance, ElemType> BoundType;

  std::vector<std::pair<ElemType, size_t>> sorted(node->Count());

  sorted.resize(node->Count());

  for (size_t i = 0; i < node->NumPoints(); i++)
  {
    sorted[i].first = node->Dataset().col(node->Point(i))[axis];
    sorted[i].second = i;
  }

  // Sort high bounds of children.
  std::sort(sorted.begin(), sorted.end(),
      [] (const std::pair<ElemType, size_t>& s1,
          const std::pair<ElemType, size_t>& s2)
      {
        return s1.first < s2.first;
      });

  size_t splitPointer = node->Count() / 2;

  axisCut = sorted[splitPointer - 1].first;

  // Check if the partition is suitable.
  if (!CheckLeafSweep(node, axis, axisCut))
    return std::numeric_limits<ElemType>::max();

  BoundType bound1(node->Bound().Dim());
  BoundType bound2(node->Bound().Dim());

  // Find bounds of two resulting nodes.
  for (size_t i = 0; i < splitPointer; i++)
    bound1 |= node->Dataset().col(node->Point(sorted[i].second));

  for (size_t i = splitPointer; i < node->NumChildren(); i++)
    bound2 |= node->Dataset().col(node->Point(sorted[i].second));

  // Evaluate the cost of the split i.e. calculate the total coverage
  // of two resulting nodes.

  return bound1.Volume() + bound2.Volume();
}
Ejemplo n.º 3
0
  Interval MeanValueForm::operator ()(const MeanValueForm::ipolynomial_type    *poly_ptr,
                                      const MeanValueForm::additional_var_data *data_ptr  ) const
  {
    Interval bound1(0.0), bound2(0.0);
    std::vector<Interval> bound_of_derivatives( data_ptr->size(), Interval(0.0) );

    std::vector<Interval> arguments( data_ptr->size() ), arguments_mid( data_ptr->size() );
    for(unsigned int i = 0; i < data_ptr->size(); i++)
      if( (*data_ptr)[ i ].operator ->() != 0 )
      {
        arguments    [ i ] = ((*data_ptr)[ i ])->domain_ - ((*data_ptr)[ i ])->devel_point_;
        arguments_mid[ i ] = Interval( arguments[ i ].mid() );
      }

    MeanValueForm::const_ipolynomial_iterator
      curr = poly_ptr->begin(),
      last = poly_ptr->end();

    while( curr != last ) //Walk trough the polynomial.
    {
      Interval prod1(1.0), prod2(1.0);

      //Evaluate the current monomial at the midpoint of the domain.
      for(unsigned int i = (*curr).key().min_var_code(); i <= (*curr).key().max_var_code(); i++)
      {
        unsigned int e = (*curr).key().expnt_of_var(i);
        if( e != 0 )
        {
          prod1 *= power( arguments    [i-1], e );
          prod2 *= power( arguments_mid[i-1], e );
        }
      }

      //Multiply with coefficient.
      prod1 *= (*curr).value();   // <---- Multiply with double value.
      prod2 *= (*curr).value();   // <---- Multiply with double value.

      //Add enclosure to bound interval.
      bound1 += prod1;
      bound2 += prod2;

      //Derivate the current monomial and evaluate it.
      for(unsigned int i = (*curr).key().min_var_code(); i <= (*curr).key().max_var_code(); i++)
      {
        unsigned int e_i = (*curr).key().expnt_of_var(i);
        if( e_i != 0 )
        {
          prod2 = e_i * power( arguments[i-1], e_i-1 ); //Value of derivative.

          unsigned int j;
          for(j = (*curr).key().min_var_code(); j < i; j++)
          {
            unsigned int e_j = (*curr).key().expnt_of_var(j);
            if( e_j != 0 )
            {
              prod2 *= power( arguments[j-1], e_j );
            }
          }
          for(j = i+1; j <= (*curr).key().max_var_code(); j++)
          {
            unsigned int e_j = (*curr).key().expnt_of_var(j);
            if( e_j != 0 )
            {
              prod2 *= power( arguments[j-1], e_j );
            }
          }

          //Multiply with coefficient.
          prod2 *= (*curr).value();   // <---- Multiply with double value.

          //Save enclosure of derivative.
          bound_of_derivatives[ i - 1 ] += prod2;
        }
      }

      ++curr;
    }

    for(unsigned int i = 0; i < bound_of_derivatives.size(); i++)
      if( bound_of_derivatives[i] != Interval(0.0) )
        bound2 += bound_of_derivatives[i] * (((*data_ptr)[i])->domain_ - (((*data_ptr)[i])->domain_).mid() );

    return bound1 & bound2; //Intersection of naive and mean value form evaluation.
  }
Ejemplo n.º 4
0
int main (int argc, char* argv[]) 
{
    int n1,n2,n3; /*n1 is trace length, n2 is the number of traces, n3 is the number of 3th axis*/
    int nfw;    /*nfw is the filter-window length*/
    int m;
    int i,j,k,ii;
    bool boundary;
    
    float *trace;
    float *tempt;
    float *temp1;
    float *extendt;
    sf_file in, out;
    
    sf_init (argc, argv); 
    in = sf_input("in");
    out = sf_output("out");
    
    if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
    if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
    n3 = sf_leftsize(in,2);
    /* get the trace length (n1) and the number of traces (n2) and n3*/
    
    if (!sf_getint("nfw",&nfw)) sf_error("Need integer input");
    /* filter-window length (positive integer)*/
    
    if (!sf_getbool("boundary",&boundary)) boundary=false;
    /* if y, boundary is data, whereas zero*/
    
    if (nfw < 1)  sf_error("Need positive integer input"); 
    if (nfw%2 == 0)  nfw = (nfw+1);
    m=(nfw-1)/2;
    
    trace = sf_floatalloc(n1*n2);
    tempt = sf_floatalloc(n1*n2);
    temp1 = sf_floatalloc(nfw);
    extendt = sf_floatalloc((n1+2*m)*n2);
    
    for(ii=0;ii<n3;ii++){
	sf_floatread(trace,n1*n2,in);
	
	for(i=0;i<n1*n2;i++){
	    tempt[i]=trace[i];
	}
	
	bound1(tempt,extendt,nfw,n1,n2,boundary);
	
	/************1-D mean filter****************/
	
	for(i=0;i<n2;i++){
	    for(j=0;j<n1;j++){
		for(k=0;k<nfw;k++){
		    temp1[k]=extendt[(n1+2*m)*i+j+k];
		}
		trace[n1*i+j]=mean(temp1,nfw);
	    }
	}
	
	sf_floatwrite(trace,n1*n2,out);
    }

    exit (0);
}
Ejemplo n.º 5
0
int main (int argc, char* argv[]) 
{
    int n1,n2,n3; /*n1 is trace length, n2 is the number of traces, n3 is the number of 3th axis*/
    int i,j,k,kk,ii;
    int nfw;    /*nfw is the reference filter-window length*/
    int tempnfw;  /*temporary variable*/
    int m;
    float medianv; /*temporary median variable*/
    bool boundary;
    int alpha,beta,gamma,delta; /*time-varying window coefficients*/
    
    float *trace;
    float *tempt; /*temporary array*/
    float *result; /*output array*/
    float *extendt;
    float *medianarray;   /*1D median filtered array*/
    float *temp1,*temp2,*temp3; /*temporary array*/
    sf_file in, out;
    
    sf_init (argc, argv); 
    in = sf_input("in");
    out = sf_output("out");
    
    if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
    if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
    n3 = sf_leftsize(in,2);
    /* get the trace length (n1) and the number of traces (n2) and n3*/
    
    if (!sf_getbool("boundary",&boundary)) boundary=false;
    /* if y, boundary is data, whereas zero*/
    
    if (!sf_getint("nfw",&nfw)) sf_error("Need integer input");
    /* reference filter-window length (>delta, positive and odd integer)*/
    
    if (!sf_getint("alpha",&alpha)) alpha=2;
    /* time-varying window parameter "alpha" (default=2)*/
    
    if (!sf_getint("beta",&beta)) beta=0;
    /* time-varying window parameter "beta" (default=0)*/
    
    if (!sf_getint("gamma",&gamma)) gamma=2;
    /* time-varying window parameter "gamma" (default=2)*/
    
    if (!sf_getint("delta",&delta)) delta=4;
    /* time-varying window parameter "delta" (default=4)*/
    
    if (alpha<beta || delta<gamma) sf_error("Need alpha>=beta && delta>=gamma"); 
    if ((alpha%2)!=0) alpha = alpha+1;
    if ((beta%2)!=0) beta = beta+1;
    if ((gamma%2)!=0) gamma = gamma+1;
    if ((delta%2)!=0) delta = delta+1;
    
    if (nfw <=delta)  sf_error("Need nfw > delta"); 
    if (nfw%2 == 0)  nfw++;
    m=(nfw-1)/2;
    tempnfw=nfw;
    
    trace = sf_floatalloc(n1*n2);
    tempt = sf_floatalloc(n1*n2);
    result = sf_floatalloc(n1*n2);
    extendt = sf_floatalloc((n1+2*m)*n2);
    medianarray =sf_floatalloc(n1*n2);
    temp1 = sf_floatalloc(nfw);
    temp2 = sf_floatalloc(n1);
    /*set the data space*/
    
    for(ii=0;ii<n3;ii++){
	sf_floatread(trace,n1*n2,in);
	for(i=0;i<n1*n2;i++){
	    tempt[i]=trace[i];
	}
	
	bound1(tempt,extendt,nfw,n1,n2,boundary);
	
	/************1D reference median filtering****************/
	
	for(i=0;i<n2;i++){
	    for(j=0;j<n1;j++){
		for(k=0;k<nfw;k++){
		    temp1[k]=extendt[(n1+2*m)*i+j+k];
		}
		medianarray[n1*i+j]=sf_quantile(m,nfw,temp1); 
	    }
	}
	medianv=0.0;
	for(i=0;i<n1*n2;i++){
	    medianv=medianv+fabs(medianarray[i]);
	}
	medianv=medianv/(1.0*n1*n2);
	
	/************1D time-varying median filter****************/
	for(i=0;i<n2;i++){
	    for(kk=0;kk<n1;kk++){
		temp2[kk]=trace[n1*i+kk];
	    }
	    for(j=0;j<n1;j++){
		if(fabs(medianarray[n1*i+j])<medianv){
		    if(fabs(medianarray[n1*i+j])<medianv/2.0){
			tempnfw=nfw+alpha;
		    }
		    else{
			tempnfw=nfw+beta;
		    }
		}
		else{
		    if(fabs(medianarray[n1*i+j])>=(medianv*2.0)){
			tempnfw=nfw-delta;
		    }
		    else{
			tempnfw=nfw-gamma;
		    }
		}
		temp3 = sf_floatalloc(tempnfw);
		bound2(temp2,temp3,n1,tempnfw,j,boundary);
		result[n1*i+j]=sf_quantile((tempnfw-1)/2,tempnfw,temp3); 
		tempnfw=nfw;
	    }
	}
	sf_floatwrite(result,n1*n2,out);
    }

    exit (0);
}
typename TreeType::ElemType MinimalCoverageSweep<SplitPolicy>::
SweepNonLeafNode(const size_t axis,
                 const TreeType* node,
                 typename TreeType::ElemType& axisCut)
{
  typedef typename TreeType::ElemType ElemType;
  typedef bound::HRectBound<metric::EuclideanDistance, ElemType> BoundType;

  std::vector<std::pair<ElemType, size_t>> sorted(node->NumChildren());

  for (size_t i = 0; i < node->NumChildren(); i++)
  {
    sorted[i].first = SplitPolicy::Bound(node->Child(i))[axis].Hi();
    sorted[i].second = i;
  }
  // Sort high bounds of children.
  std::sort(sorted.begin(), sorted.end(),
      [] (const std::pair<ElemType, size_t>& s1,
          const std::pair<ElemType, size_t>& s2)
      {
        return s1.first < s2.first;
      });

  size_t splitPointer = node->NumChildren() / 2;

  axisCut = sorted[splitPointer - 1].first;

  // Check if the midpoint split is suitable.
  if (!CheckNonLeafSweep(node, axis, axisCut))
  {
    // Find any suitable partition if the default partition is not acceptable.
    for (splitPointer = 1; splitPointer < sorted.size(); splitPointer++)
    {
      axisCut = sorted[splitPointer - 1].first;
      if (CheckNonLeafSweep(node, axis, axisCut))
        break;
    }

    if (splitPointer == node->NumChildren())
      return std::numeric_limits<ElemType>::max();
  }

  BoundType bound1(node->Bound().Dim());
  BoundType bound2(node->Bound().Dim());

  // Find bounds of two resulting nodes.
  for (size_t i = 0; i < splitPointer; i++)
    bound1 |= node->Child(sorted[i].second).Bound();

  for (size_t i = splitPointer; i < node->NumChildren(); i++)
    bound2 |= node->Child(sorted[i].second).Bound();


  // Evaluate the cost of the split i.e. calculate the total coverage
  // of two resulting nodes.

  ElemType area1 = bound1.Volume();
  ElemType area2 = bound2.Volume();

  return area1 + area2;
}