static PyObject * DiffractionAnalysisWrap_BilinearInterpolation(
        PyObject *self, PyObject *args) {
    double x, y;
    PyArrayObject *data;

    PyArg_ParseTuple(args,"O!dd",&PyArray_Type,&data,&x,&y);
    return Py_BuildValue("d",bilinearInterpolation(data,x,y));
}
Example #2
0
Vec4D CSceneData::getColor(float fX, float fY)const
{
	int nCellX = fX;
	int nCellY = fY;
	float u = fX - nCellX;
	float v = fY - nCellY;
	Vec4D a = getVertexColor(nCellX,	nCellY);
	Vec4D b = getVertexColor(nCellX+1,	nCellY);
	Vec4D c = getVertexColor(nCellX,	nCellY+1);
	Vec4D d = getVertexColor(nCellX+1,	nCellY+1);
	return bilinearInterpolation(a,b,c,d,u,v);
}
Example #3
0
float CSceneData::getHeight(float fX, float fY)const
{
	int nCellX = fX;
	int nCellY = fY;
	float u = fX - nCellX;
	float v = fY - nCellY;
	float a = getVertexHeight(nCellX,	nCellY);
	float b = getVertexHeight(nCellX+1,	nCellY);
	float c = getVertexHeight(nCellX,	nCellY+1);
	float d = getVertexHeight(nCellX+1,	nCellY+1);
	return bilinearInterpolation(a,b,c,d,u,v);
}
Example #4
0
QRgb NwwMapImage::pixel( double const lonRad, double const latRad )
{
    double const x = lonRadToPixelX( lonRad );
    double const y = latRadToPixelY( latRad );

    switch ( m_interpolationMethod ) {
    case NearestNeighborInterpolation:
        return nearestNeighbor( x, y );
    case BilinearInterpolation:
        return bilinearInterpolation( x, y );
    default:
        return nearestNeighbor( x, y );
    }
}
Example #5
0
template <typename PointInT, typename PointOutT, typename IntensityT> void
pcl::BriskKeypoint2D<PointInT, PointOutT, IntensityT>::detectKeypoints (PointCloudOut &output)
{
  // image size
  const int width = int (input_->width);
  const int height = int (input_->height);

  // destination for intensity data; will be forwarded to BRISK
  std::vector<unsigned char> image_data (width*height);

  for (size_t i = 0; i < image_data.size (); ++i)
    image_data[i] = static_cast<unsigned char> (intensity_ ((*input_)[i]));

  pcl::keypoints::brisk::ScaleSpace brisk_scale_space (octaves_);
  brisk_scale_space.constructPyramid (image_data, width, height);
  // Check if the template types are the same. If true, avoid a copy.
  // The PointOutT MUST be registered using the POINT_CLOUD_REGISTER_POINT_STRUCT macro!
  if (isSamePointType<PointOutT, pcl::PointWithScale> ())
    brisk_scale_space.getKeypoints (threshold_, output.points);
  else
  {
    pcl::PointCloud<pcl::PointWithScale> output_temp;
    brisk_scale_space.getKeypoints (threshold_, output_temp.points);
    pcl::copyPointCloud<pcl::PointWithScale, PointOutT> (output_temp, output);
  }

  // we do not change the denseness
  output.width = int (output.points.size ());
  output.height = 1;
  output.is_dense = false;      // set to false to be sure

  // 2nd pass to remove the invalid set of 3D keypoints
  if (remove_invalid_3D_keypoints_)
  {
    PointCloudOut output_clean;
    for (size_t i = 0; i < output.size (); ++i)
    {
      PointOutT pt;
      // Interpolate its position in 3D, as the "u" and "v" are subpixel accurate
      bilinearInterpolation (input_, output[i].x, output[i].y, pt);

      // Check if the point is finite
      if (pcl::isFinite (pt))
        output_clean.push_back (output[i]);
    }
    output = output_clean;
    output.is_dense = true;      // set to true as there's no keypoint at an invalid XYZ
  }
}
Example #6
0
const vec3 FileTexture::getTexel(float s, float t, const vec2 &scale) const {
	s *= scale.s;
	t *= scale.t;

	float wrappedS;
	float wrappedT;

	if (s >= 0)
		wrappedS = s - (int)s;
	else
		wrappedS = 1 - (abs(s) - (int)abs(s));

	if (t >= 0)
		wrappedT = t - (int)t;
	else
		wrappedT = 1 - (abs(t) - (int)abs(t));

	//return getTexelFromFile(wrappedS*(width-1), wrappedT*(height-1));
	return bilinearInterpolation(wrappedS, wrappedT);
}
/*
 * This function does the caking.
 */
static PyObject * DiffractionAnalysisWrap_cake(PyObject *self, PyObject *args) {
    PyArrayObject *diffractionData;
    PyArrayObject *cake;
    // the dimensions of the caked data
    int dimensions[2];

    double centerX,centerY,distance,energy,alpha,beta,rotation;
    double qOrTwoThetaLower,qOrTwoThetaUpper;
    int numQOrTwoTheta;
    double chiLower,chiUpper;
    int numChi;
    double pixelLength,pixelHeight;
    double cos_beta,sin_beta,cos_alpha,sin_alpha,cos_rotation,sin_rotation;
    double x,y;
    double q,chi; 
    double qOrTwoTheta; 
    int qOrTwoThetaBin,chiBin;
    double qOrTwoThetaStep,chiStep;
    double intensity;
    int doPolarizationCorrection;
    double P,twoTheta;
    int doGreaterThanMask;
    double greaterThanMask;
    int doLessThanMask;
    double lessThanMask;

    int doPolygonMask;
    PyArrayObject * polygonsX;
    PyArrayObject * polygonsY;
    PyArrayObject * polygonBeginningsIndex;
    PyArrayObject * polygonNumberOfItems;

    char *type;

    // get all of the parameters out of the python call
    PyArg_ParseTuple(args,"O!dddddddddiddiidididiO!O!O!O!dds",&PyArray_Type,&diffractionData,
        &centerX,&centerY,&distance,&energy,&alpha,&beta,&rotation,
        &qOrTwoThetaLower,&qOrTwoThetaUpper,&numQOrTwoTheta,
        &chiLower,&chiUpper,&numChi,
        &doPolarizationCorrection,&P,
        &doGreaterThanMask,&greaterThanMask,&doLessThanMask,&lessThanMask,
        &doPolygonMask,
        &PyArray_Type,&polygonsX,
        &PyArray_Type,&polygonsY,
        &PyArray_Type,&polygonBeginningsIndex,
        &PyArray_Type,&polygonNumberOfItems,
        &pixelLength,&pixelHeight,&type);


    // the types of integration
    // Remeber, strcmp returns 0 when they equal 
    if (strcmp(type,"Q") != 0 && strcmp(type,"2theta") != 0) {
        PyErr_SetString( PyExc_Exception, 
                "The type of integration must be Q, or 2theta");
        return 0;
    }

    // passed array has the diffraction data
    if (diffractionData->nd != 2 || 
            diffractionData->descr->type_num != PyArray_INT) {
        PyErr_SetString(PyExc_ValueError,
            "diffractionData must be two-dimensional and of type integer");
        return 0;
    }

    // create a new Numeric data structure to hold the cake
    dimensions[0]=numChi;
    dimensions[1]=numQOrTwoTheta;
    cake=(PyArrayObject *)PyArray_FromDims(2,dimensions,PyArray_DOUBLE);

    // calculate sin & cos for later use.
    cos_beta  = cos(beta*PI/180.0);
    sin_beta  = sin(beta*PI/180.0);
    cos_alpha = cos(alpha*PI/180.0);
    sin_alpha = sin(alpha*PI/180.0);
    cos_rotation = cos(rotation*PI/180.0);
    sin_rotation = sin(rotation*PI/180.0); 

    // calulate the step size between different bins
    qOrTwoThetaStep = (qOrTwoThetaUpper-qOrTwoThetaLower)/(numQOrTwoTheta-1);
    chiStep = (chiUpper-chiLower)/(numChi-1);

    // for each bin
    for (qOrTwoThetaBin = 0; qOrTwoThetaBin < numQOrTwoTheta; qOrTwoThetaBin += 1) {
        for (chiBin = 0; chiBin < numChi; chiBin += 1) {

            // get into the middle of the cell
            qOrTwoTheta = qOrTwoThetaLower + qOrTwoThetaBin*qOrTwoThetaStep + 
                    qOrTwoThetaStep/2.0;
            chi = chiLower + chiBin*chiStep + chiStep/2.0;

            if (strcmp(type,"Q")==0) {
                q = qOrTwoTheta;
            } else {
                q = convertTwoThetaToQ(qOrTwoTheta,convertEnergyToWavelength(energy)); 
            }

            getXY(centerX,centerY,distance,energy,q,chi,
                    pixelLength,pixelHeight,rotation,
                    cos_beta,sin_beta,cos_alpha,sin_alpha,
                    cos_rotation,sin_rotation,&x,&y);

            // if the qOrTwoTheta,chi value is in the diffraction 
            // image, then find the intensity. Note that there is 
            // only diffraction data up to (dimension-1)
            if (x >= 0 && x <= (diffractionData->dimensions[0]-1) &&
                    y >= 0 && y <= (diffractionData->dimensions[1]-1)) {

                intensity = bilinearInterpolation(diffractionData, x, y);

                // possibly do the polarization correction
                if (doPolarizationCorrection) {

                    twoTheta = convertQToTwoTheta(q,
                            convertEnergyToWavelength(energy));

                    intensity = polarizationCorrection(intensity,P,twoTheta,chi);
                }

                // clip all intensity values to be at least 0.
                if (intensity < 0) intensity = 0;
                
                if (doPolygonMask && isInPolygons(polygonsX,polygonsY,
                        polygonBeginningsIndex,polygonNumberOfItems,x,y)) {

                // if we are doing a polygon mask and our pixel is 
                // in one of the polygons, then we should assign its 
                // value to be -4 (by convention)
                *(double *)(cake->data + chiBin*cake->strides[0] + 
                        qOrTwoThetaBin*cake->strides[1]) = -4;

                } else if (doGreaterThanMask && intensity > greaterThanMask) {
                    // if we are doing the greater than mask, if the 
                    // current pixel is greater then the threshold, 
                    // then we should assign its value to be -2 
                    // (by convention).
                    *(double *)(cake->data + chiBin*cake->strides[0] + 
                            qOrTwoThetaBin*cake->strides[1]) = -2;
                } else if (doLessThanMask && intensity < lessThanMask) {
                    // if we are doing the lower than mask, if the 
                    // current pixel is less then the threshold, then 
                    // we should assign its value to be -3 (by convention)
                    *(double *)(cake->data + chiBin*cake->strides[0] + 
                            qOrTwoThetaBin*cake->strides[1]) = -3;
                } else {
                    *(double *)(cake->data + chiBin*cake->strides[0] + 
                            qOrTwoThetaBin*cake->strides[1]) = intensity;
                }

            } else { // otherwise, define outside the image as -1 intensity.
                *(double *)(cake->data + chiBin*cake->strides[0] + 
                        qOrTwoThetaBin*cake->strides[1]) = -1;
            }
        }
    }
    return Py_BuildValue("N",cake);
}