示例#1
0
unsigned int stable_count(unsigned long ary[],
					 unsigned long n, unsigned long nbits,
					 unsigned long offset, unsigned long size)
{
	unsigned long j = 1 << size;
	unsigned long *count = malloc(sizeof(unsigned long)*j); 
	unsigned long *pos = malloc(sizeof(unsigned long)*j); 
	unsigned long *output = malloc(sizeof(unsigned long)*n);
	
	unsigned long x; 
	
	for(x=0;x<j;x++){ 
		count[x] = pos[x] = 0;
	}
		
	for(x=0;x<n;x++){ 
		unsigned long m = masked( ary[x], offset, size);
		count[m]++;
	}
	
	for(x=0;x<=j;x++){
		pos[x+1] = pos[x] + count[x];
	}
	
	for(x=0;x<n;x++){ 
		unsigned long m = masked( ary[x], offset, size);
		output[pos[m]++] = ary[x];
	}
		
	for(x=0;x<n;x++){
		ary[x] = output[x];
	}
	
	return 0; /* success */
}
示例#2
0
文件: fill.c 项目: j0sh/thesis
static void accum(IplImage *a, IplImage *acc, int ax, int ay, int accx, int accy, int dist, IplImage *mask)
{
    float weight = 1.0f/(dist+1);
    int dx, dy, dir = 1, i, w = PATCH_W, h = PATCH_W;
    int stride = a->widthStep, astride = acc->widthStep;
    uint8_t *data = (uint8_t*)a->imageData + ay*stride + ax*a->nChannels;
    uint8_t *adata = (uint8_t*)acc->imageData + accy*astride + accx*acc->nChannels*sizeof(float);
    if (!masked(mask, accx, accy)) return;
    if (!masked(mask, accx, accy)) {
        update_accum(a, acc, ax, ay, accx, accy, weight);
        return;
    }
    if (ax+w >= a->width) w -= ax+w - a->width;
    if (accx+w >= acc->width) w -= accx+w - acc->width;
    if (ay+h >= a->height) h -= ay+h - a->height;
    if (accy+h >= acc->height) h -= accy+h - acc->height;
    for (dy = 0; dy < h; dy++) {
        uint8_t *line = data;
        float *aline = (float*)adata;
        for (dx = 0; dx < w; dx++) {
            //if (!masked(mask, rx, ry)) continue;
            for (i = 0; i < a->nChannels; i++) aline[i] += weight*line[i];
            aline[a->nChannels] += weight;
            line += dir*a->nChannels;
            aline += dir*acc->nChannels;
        }
        data += a->widthStep;
        adata += acc->widthStep;
    }
}
示例#3
0
WSFrameHeaderInfo WSHyBiFrameHeader::info() const {
  WSFrameHeaderInfo inf;
  inf.fin = fin();
  inf.opcode = opcode();
  inf.hasLength = true;
  inf.masked = masked();
  if (masked()) {
    inf.maskingKey.resize(4);
    maskingKey(&inf.maskingKey[0]);
  }
  inf.payloadLength = payloadLength();
  return inf;
}
示例#4
0
//=============================================================================
// Fill 4volume.
//=============================================================================
void TbTracking::fillATrackVolume(TbTrackVolume* track_volume) {
  // Fills the given TbTrackVolume (that has a particular space-time volume)
  // with clusters from all planes (ie m_clusters) that fall in this space-time
  // volume.

  for (unsigned int iplane = 0; iplane < m_nPlanes; iplane++) {
    // Check for any clusters, or track contains seed condition.
    if (m_clusterFinder->empty(iplane) ||
        iplane == track_volume->seed()->plane() || masked(iplane))
      continue;

    // Create an iterator and find the appropriate cluster on the ith plane
    // whose TOA is at the start of this TbTrackVolumes' time window.
    auto ic = m_clusterFinder->getIterator(track_volume->t_lower(), iplane);
    const auto end = m_clusterFinder->end(iplane);
    // Loop until the TOA reaches the end of this TbTrackVolumes' time window.
    // (dummy end condition used in the for loop).
    for (; ic != end; ++ic) {
      // Add cluster if inside and not already tracked.
      track_volume->consider_cluster((*ic));
      // Stop if too far ahead in time.
      if ((*ic)->htime() > track_volume->t_upper()) break;
    }
  }
}
示例#5
0
static void makeOligoHistogram(char *fileName, struct seqList *seqList, 
    int oligoSize, int **retTable, int *retTotal)
/* Make up table of oligo occurences. Either pass in an FA file or a seqList.
 * (the other should be NULL). */
{
FILE *f = NULL;
int tableSize = (1<<(oligoSize+oligoSize));
int tableByteSize = tableSize * sizeof(int);
int *table = needLargeMem(tableByteSize);
struct dnaSeq *seq;
struct seqList *seqEl = seqList;
int *softMask = NULL;
int total = 0;

if (seqList == NULL)
    f = mustOpen(fileName, "rb");

memset(table, 0, tableByteSize);
for (;;)
    {
    DNA *dna;
    int size;
    int endIx;
    int i;
    int oliVal;
    if (seqList != NULL)
        {
        if (seqEl == NULL)
            break;
        seq = seqEl->seq;
        softMask = seqEl->softMask;
        seqEl = seqEl->next;
        }
    else
        {
        seq = faReadOneDnaSeq(f, "", TRUE);
        if (seq == NULL)
            break;
        }
    dna = seq->dna;
    size = seq->size;
    endIx = size-oligoSize;
    for (i=0; i<=endIx; ++i)
        {
        if (softMask == NULL || !masked(softMask+i, oligoSize) )
            {
            if ((oliVal = oligoVal(dna+i, oligoSize)) >= 0)
                {
                table[oliVal] += 1;
                ++total;
                }
            }
        }
    if (seqList == NULL)
        freeDnaSeq(&seq);
    }
carefulClose(&f);
*retTable = table;
*retTotal = total;
}
示例#6
0
void WSHyBiFrameHeader::maskingKey(uint8_t key[4]) const {
  if (!masked())
    memset(key, 0, 4);
  else {
    key[0] = read(9 + payloadLengthLength(), 8);
    key[1] = read(9 + payloadLengthLength() + 8, 8);
    key[2] = read(9 + payloadLengthLength() + 16, 8);
    key[3] = read(9 + payloadLengthLength() + 24, 8);
  }
}
示例#7
0
文件: fill.c 项目: j0sh/thesis
static void improve_guess(IplImage *a, IplImage *b, int ax, int ay, int *xbest, int *ybest, int *dbest, int bx, int by, IplImage *mask)
{
    if (masked(mask, bx, by)) return;
    int db = *dbest;
    int d = dist(a, b, ax, ay, bx, by, db, mask);
    if (d < db) {
        *dbest = d;
        *xbest = bx;
        *ybest = by;
    }
}
示例#8
0
文件: irq.c 项目: AdamRLukaitis/spoon
int release_irq( struct thread *t, int irq )
{
	int ans = -1;

	if ( (irq < 0) || (irq >= IRQ_COUNT) ) return -1;
	
	acquire_spinlock( &irq_lock );

	  if ( handlers[irq] == t )
	  {
		  handlers[irq] = NULL;
		  if ( masked(irq) == 0 ) mask_irq( irq );
		  ans = 0;
	  }
	
	release_spinlock( &irq_lock );
	return ans;
}
示例#9
0
文件: irq.c 项目: AdamRLukaitis/spoon
int request_irq( struct thread *t, int irq )
{
	int ans = -1;
	
	if ( (irq < 0) || (irq >= IRQ_COUNT) ) return -1;
	
	acquire_spinlock( &irq_lock );
	
	  if ( handlers[irq] == NULL )
	  {
		  handlers[irq] = t;
		  
		  t->state = THREAD_IRQ;

		  if ( masked( irq ) != 0 ) unmask_irq( irq );
		  ans = 0;
	  }

	
	release_spinlock( &irq_lock );
	return ans;
}
示例#10
0
//=============================================================================
// Actual tracking
//=============================================================================
void TbTracking::performTracking() {
  // The working of this algorithm is similar to the cluster maker, such that:
  // - Loop over some set of seed clusters (those on the m_SeedPlanes).
  // - Create a container (TbTrackVolume) centered on each seed cluster
  // (in space and time).
  // - Impose the condition that any formed track must contain this seed.
  // - Evaluate that 4-volume, to see if it contained a track.
  // - If a choice (e.g. more than one possible combination of clusters),
  // take the best fitting. Priority is given to more complete tracks.
  // - If another track happened to be in the 4volume, but not
  //   containing this seed, then it will be found later.

  // Iterate over planes in the specified order.
  for (const auto& plane : m_PlaneSearchOrder) {
    // Iterate over this planes' clusters - first check for any.
    if (masked(plane) || m_clusterFinder->empty(plane)) continue;
    auto ic = m_clusterFinder->first(plane);
    const auto end = m_clusterFinder->end(plane);
    for (; ic != end; ++ic) {

      // Check if the seed has already been used.
      if ((*ic)->tracked()) continue;
      // Form the TbTrackVolume container, and fill with clusters that fall
      // in its space-time volume.
      TbTrackVolume* track_volume =
          new TbTrackVolume((*ic), m_search_3vol, m_nPlanes, m_twindow,
                            m_vol_radius, m_vol_radiusY, m_vol_theta,
                            m_vol_thetaY, m_MinNClusters);
      fillATrackVolume(track_volume);

      // Look for a track - automatically keeps if suitable.
      evaluateTrackVolume(track_volume);
      // PoorMansEvaluation(track_volume); // Alternative evaluator.

      delete track_volume;
    }
  }
}
示例#11
0
/** Executes the algorithm
 *
 */
void SplineBackground::exec()
{

  API::MatrixWorkspace_sptr inWS = getProperty("InputWorkspace");
  int spec = getProperty("WorkspaceIndex");

  if (spec > static_cast<int>(inWS->getNumberHistograms()))
    throw std::out_of_range("WorkspaceIndex is out of range.");

  const MantidVec& X = inWS->readX(spec);
  const MantidVec& Y = inWS->readY(spec);
  const MantidVec& E = inWS->readE(spec);
  const bool isHistogram = inWS->isHistogramData();

  const int ncoeffs = getProperty("NCoeff");
  const int k = 4; // order of the spline + 1 (cubic)
  const int nbreak = ncoeffs - (k - 2);

  if (nbreak <= 0)
    throw std::out_of_range("Too low NCoeff");

  gsl_bspline_workspace *bw;
  gsl_vector *B;

  gsl_vector *c, *w, *x, *y;
  gsl_matrix *Z, *cov;
  gsl_multifit_linear_workspace *mw;
  double chisq;

  int n = static_cast<int>(Y.size());
  bool isMasked = inWS->hasMaskedBins(spec);
  std::vector<int> masked(Y.size());
  if (isMasked)
  {
    for(API::MatrixWorkspace::MaskList::const_iterator it=inWS->maskedBins(spec).begin();it!=inWS->maskedBins(spec).end();++it)
      masked[it->first] = 1;
    n -= static_cast<int>(inWS->maskedBins(spec).size());
  }

  if (n < ncoeffs)
  {
    g_log.error("Too many basis functions (NCoeff)");
    throw std::out_of_range("Too many basis functions (NCoeff)");
  }

  /* allocate a cubic bspline workspace (k = 4) */
  bw = gsl_bspline_alloc(k, nbreak);
  B = gsl_vector_alloc(ncoeffs);

  x = gsl_vector_alloc(n);
  y = gsl_vector_alloc(n);
  Z = gsl_matrix_alloc(n, ncoeffs);
  c = gsl_vector_alloc(ncoeffs);
  w = gsl_vector_alloc(n);
  cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
  mw = gsl_multifit_linear_alloc(n, ncoeffs);

  /* this is the data to be fitted */
  int j = 0;
  for (MantidVec::size_type i = 0; i < Y.size(); ++i)
  {
    if (isMasked && masked[i]) continue;
    gsl_vector_set(x, j, (isHistogram ? (0.5*(X[i]+X[i+1])) : X[i])); // Middle of the bins, if a histogram
    gsl_vector_set(y, j, Y[i]);
    gsl_vector_set(w, j, E[i]>0.?1./(E[i]*E[i]):0.);

    ++j;
  }

  if (n != j)
  {
    gsl_bspline_free(bw);
    gsl_vector_free(B);
    gsl_vector_free(x);
    gsl_vector_free(y);
    gsl_matrix_free(Z);
    gsl_vector_free(c);
    gsl_vector_free(w);
    gsl_matrix_free(cov);
    gsl_multifit_linear_free(mw);

    throw std::runtime_error("Assertion failed: n != j");
  }

  double xStart = X.front();
  double xEnd =   X.back();

  /* use uniform breakpoints */
  gsl_bspline_knots_uniform(xStart, xEnd, bw);

  /* construct the fit matrix X */
  for (int i = 0; i < n; ++i)
  {
    double xi=gsl_vector_get(x, i);

    /* compute B_j(xi) for all j */
    gsl_bspline_eval(xi, B, bw);

    /* fill in row i of X */
    for (j = 0; j < ncoeffs; ++j)
    {
      double Bj = gsl_vector_get(B, j);
      gsl_matrix_set(Z, i, j, Bj);
    }
  }

  /* do the fit */
  gsl_multifit_wlinear(Z, w, y, c, cov, &chisq, mw);

  /* output the smoothed curve */
  API::MatrixWorkspace_sptr outWS = WorkspaceFactory::Instance().create(inWS,1,X.size(),Y.size());
  {
    outWS->getAxis(1)->setValue(0, inWS->getAxis(1)->spectraNo(spec));
    double xi, yi, yerr;
    for (MantidVec::size_type i=0;i<Y.size();i++)
    {
      xi = X[i];
      gsl_bspline_eval(xi, B, bw);
      gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
      outWS->dataY(0)[i] = yi;
      outWS->dataE(0)[i] = yerr;
    }
    outWS->dataX(0) = X;
  }

  gsl_bspline_free(bw);
  gsl_vector_free(B);
  gsl_vector_free(x);
  gsl_vector_free(y);
  gsl_matrix_free(Z);
  gsl_vector_free(c);
  gsl_vector_free(w);
  gsl_matrix_free(cov);
  gsl_multifit_linear_free(mw);

  setProperty("OutputWorkspace",outWS);

}
示例#12
0
size_t poisson_square(tkernel<glm::tvec2<T, P>> & kernel, const T min_dist, const unsigned int num_probes)
{
    assert(kernel.depth() == 1);

    std::random_device RD;
    std::mt19937_64 generator(RD());

    std::uniform_real_distribution<> radius_dist(min_dist, min_dist * 2.0);
    std::uniform_real_distribution<> angle_dist(0.0, 2.0 * glm::pi<T>());

    std::uniform_int_distribution<> int_distribute(0, std::numeric_limits<int>::max());

    auto occupancy = poisson_square_map<T, P>{ min_dist };

    size_t k = 0; // number of valid/final points within the kernel
    kernel[k] = glm::tvec2<T, P>(0.5, 0.5);

    auto actives = std::list<size_t>();
    actives.push_back(k);

    occupancy.mask(kernel[k], k);

    while (!actives.empty() && k < kernel.size() - 1)
    {
        // randomly pick an active point
        const auto pick = int_distribute(generator);

        auto pick_it = actives.begin();
        std::advance(pick_it, pick % actives.size());

        const auto active = kernel[*pick_it];


        std::vector<std::tuple<glm::tvec2<T, P>, T>> probes{ num_probes };

        #pragma omp parallel for
        for (int i = 0; i < static_cast<int>(num_probes); ++i)
        {
            const auto r = radius_dist(generator);
            const auto a = angle_dist(generator);

            auto probe = glm::tvec2<T, P>{ active.x + r * cos(a), active.y + r * sin(a) };

            // within square? (tilable)
            if (probe.x < 0.0)
                probe.x += 1.0;
            else if (probe.x >= 1.0)
                probe.x -= 1.0;

            if (probe.y < 0.0)
                probe.y += 1.0;
            else if (probe.y >= 1.0)
                probe.y -= 1.0;

            // Note: do NOT make this optimization
            //if (!tilable && (probe.x < 0.0 || probe.x > 1.0 || probe.y < 0.0 || probe.y > 1.0))
            //    continue;

            // points within min_dist?
            const auto masked = occupancy.masked(probe, kernel);
            const auto delta = glm::abs(active - probe);

            probes[i] = std::make_tuple<glm::tvec2<T, P>, T>(std::move(probe), (masked ? static_cast<T>(-1.0) : glm::dot(delta, delta)));
        }
        
        // pick nearest probe from sample set
        glm::vec2 nearest_probe;
        auto nearest_dist = 4 * min_dist * min_dist;
        auto nearest_found = false;

        for (int i = 0; i < static_cast<int>(num_probes); ++i)
        {
            // is this nearest point yet? - optimized by using square distance -> skipping sqrt
            const auto new_dist = std::get<1>(probes[i]);
            if (new_dist < 0.0 || nearest_dist < new_dist)
                continue;

            if (!nearest_found)
                nearest_found = true;

            nearest_dist = new_dist;
            nearest_probe = std::get<0>(probes[i]);
        }

        if (!nearest_found && (actives.size() > 0 || k > 1))
        {
            actives.erase(pick_it);
            continue;
        }

        kernel[++k] = nearest_probe;
        actives.push_back(k);

        occupancy.mask(nearest_probe, k);
    }

    return k + 1;
}
示例#13
0
uint8_t WSHyBiFrameHeader::maskingKeyLength() const {
  return masked() ? 32 : 0;
}
示例#14
0
文件: fill.c 项目: j0sh/thesis
static void patchmatch(IplImage *a, IplImage *b, IplImage *ann, IplImage *annd, IplImage *mask)
{
    int iter, rs_start, mag;
    int w = ann->width, h = ann->height;
    int32_t *data = (int32_t*)ann->imageData;
    int32_t *ddata = (int32_t*)annd->imageData;
    int stride = ann->widthStep/sizeof(int32_t);
    int aew = a->width - PATCH_W + 1;
    int aeh = a->height - PATCH_W + 1;
    int bew = b->width - PATCH_W + 1;
    int beh = b->height - PATCH_W + 1;

    int ax, ay;

    // initialize with random values
    for (ay = 0; ay < h; ay++) {
        int xy = ay * stride;
        for (ax = 0; ax < w; ax++) {
            uint16_t bx = ax;
            uint16_t by = ay;
            while (masked(mask, bx, by)) {
                bx = rand() % bew;
                by = rand() % beh;
            }
            *(data + xy) = XY_TO_INT(bx, by);
            *(ddata + xy) = dist(a, b, ax, ay, bx, by, 0, mask);
            xy += 1;
        }
    }

    for (iter = 0; iter < PM_ITERS; iter++) {
        int ystart = 0, yend = aeh, ychange = 1;
        int xstart = 0, xend = aew, xchange = 1;
        if (iter % 2) {
            ystart = yend - 1; yend = -1; ychange = -1;
            xstart = xend - 1; xend = -1; xchange = -1;
        }
        for (ay = ystart; ay != yend; ay += ychange) {
            for (ax = xstart; ax != xend; ax += xchange) {
                if (!masked(mask, ax, ay)) continue;
                // current best guess
                int xy = ay * stride + ax;
                int v = *(data + xy);
                int xbest = XY_TO_X(v), ybest = XY_TO_Y(v);
                int dbest = *(ddata + xy);

                // Propagation: Improve current guess by trying
                // correspondences from left and above,
                // or below and right on odd iterations
                if ((unsigned)(ax - xchange) < (unsigned)aew) {
                    int vp = *(data + ay * stride + (ax - xchange));
                    int xp = XY_TO_X(vp) + xchange, yp = XY_TO_Y(vp);
                    if ((unsigned)xp < (unsigned)bew) {
                        improve_guess(a, b, ax, ay, &xbest, &ybest, &dbest, xp, yp, mask);
                    }
                }

                if ((unsigned)(ay - ychange) < (unsigned)aeh) {
                    int vp = *(data + ay * stride + (ax - xchange));
                    int xp = XY_TO_X(vp), yp = XY_TO_Y(vp) + ychange;
                    if ((unsigned)yp < (unsigned)beh) {
                        improve_guess(a, b, ax, ay, &xbest, &ybest, &dbest, xp, yp, mask);
                    }
                }

                rs_start = RS_MAX;
                if (rs_start > max(b->width, b->height)) rs_start = max(b->width, b->height);
                for (mag = rs_start; mag >= 1; mag /= 2) {
                    // sampling window
                    int xmin = max(xbest - mag, 0);
                    int xmax = min(xbest + mag + 1, bew);
                    int ymin = max(ybest - mag, 0);
                    int ymax = min(ybest + mag + 1, beh);
                    int xp = xmin + rand() % (xmax - xmin);
                    int yp = ymin + rand() % (ymax - ymin);
                    improve_guess(a, b, ax, ay, &xbest, &ybest, &dbest, xp, yp, mask);
                }

                *(data +  xy) = XY_TO_INT(xbest, ybest);
                *(ddata + xy) = dbest;
            }
        }
    }
}
int is_anagram(char *s1, char *s2) {
    return masked(s1) == masked(s2);
}
示例#16
0
void UfrawWorker::developImpl(bool preview, WorkerBase *predecessor)
{
    qDebug() << "UfrawWorker::developImpl()" << this << predecessor;

    double progressPhaseA = 0.1;
    double progressPhaseB = 0.5;

    int nof = config()->settings()->getSetting(UfrawSettings::Fuse)->value().toInt();
    Magick::Image normalImg;
    std::vector<UfrawProcess>  ufraw(nof);
    int firstIdx = -(nof-1)/2;
    for( int i=0; i<nof; i++ )
    {
        setProgress( double(i) / nof * progressPhaseA );
        qDebug() << "UfrawWorker::developImpl() running" << i << "...";
        run( ufraw[i], preview, firstIdx+i, nof );
    }
    for( int i=0; i<nof; i++ )
    {
        setProgress( progressPhaseA + double(i) / nof * progressPhaseB );
        ufraw[i].waitForFinished(-1);
        qDebug() << "UfrawWorker::developImpl()" << i << "finished with exitcode" << ufraw[i].exitCode() << ":" << ufraw[i].console();
        if( ufraw[i].exitCode() == 0 )
        {
            bool isNormalExposed = (firstIdx+i)==0;
            bool isOverExposed   = (firstIdx+i)>0;
            qDebug() << "UfrawWorker::developImpl()" << i << "loading" << ufraw[i].output();
            Magick::Image img, mask;
            img.read( ufraw[i].output().toStdString().c_str() );
            if( isNormalExposed )
            {
                normalImg = img;
                normalImg.write( QString("/Users/manuel/tmp/test_normal.tif").toStdString().c_str() );
            }
            else
            {
                mask = masked( isOverExposed, 0.98, img );
                mask.write( ufraw[i].output().toStdString().c_str() );
                mask.write( QString("/Users/manuel/tmp/test_masked%1.tif").arg(i).toStdString().c_str() );
            }
        }
    }

    QStringList rawImages;
    for( int i=0; i<nof; i++ )
    {
        rawImages << ufraw[i].output();
    }

    if( nof > 1 )
    {
        double sigma = config()->settings()->getSetting(UfrawSettings::ExposureSigma)->value().toDouble();
        EnfuseProcess enfuse;
        enfuse.setProgram( m_enfusePath );
        enfuse.setInputs( rawImages );
        enfuse.setExposureSigma( sigma );
        connect( &enfuse, &EnfuseProcess::progress, [&](double progress) {
            setProgress( progressPhaseA + progressPhaseB + (1-progressPhaseA-progressPhaseB)*progress );
        });
        enfuse.run();
        enfuse.waitForFinished(-1);
        qDebug() << "UfrawWorker::developImpl() enfuse finished with exitcode" << enfuse.exitCode() << ":" << enfuse.console();
        if( enfuse.exitCode() == 0 )
        {
            qDebug() << "UfrawWorker::developImpl()" << "loading" << enfuse.output();
            m_img.read( enfuse.output().toStdString().c_str() );
            m_img.matte(false);
            qDebug() << "UfrawWorker::developImpl() fused" << m_img.format().c_str();
        }
    }
    else
    {
        m_img = normalImg;
    }
}