void ra_checker::check_value_gpr(node *n, unsigned id, value *v) {
sel_chan gpr = v->gpr;
if (!gpr) {
sb_ostringstream o;
o << "operand value " << *v << " is not allocated";
error(n, id, o.str());
return;
}
reg_value_map::iterator F = rmap().find(v->gpr);
if (F == rmap().end()) {
sb_ostringstream o;
o << "operand value " << *v << " was not previously written to its gpr";
error(n, id, o.str());
return;
}
if (!F->second->v_equal(v)) {
sb_ostringstream o;
o << "expected operand value " << *v
<< ", gpr contains " << *(F->second);
error(n, id, o.str());
return;
}
}
void ra_checker::process_op_dst(node *n) {
unsigned id = 0;
for (vvec::iterator I = n->dst.begin(), E = n->dst.end(); I != E; ++I) {
value *v = *I;
++id;
if (!v)
continue;
if (v->is_sgpr()) {
if (!v->gpr) {
sb_ostringstream o;
o << "destination operand " << *v << " is not allocated";
error(n, id, o.str());
return;
}
rmap()[v->gpr] = v;
} else if (v->is_rel()) {
if (v->rel->is_const()) {
rmap()[v->get_final_gpr()] = v;
} else {
unsigned sz = v->array->array_size;
unsigned start = v->array->gpr;
for (unsigned i = 0; i < sz; ++i) {
rmap()[start + (i << 2)] = v;
}
}
}
}
}
int main(int argc, char * argv[])
{
try
{
::libmaus::util::ArgInfo arginfo(argc,argv);
::libmaus::util::TempFileRemovalContainer::setup();
::std::vector<std::string> const & inputfilenames = arginfo.restargs;
char const * fasuffixes[] = { ".fa", ".fasta", 0 };
std::string deftmpname = libmaus::util::OutputFileNameTools::endClipLcp(inputfilenames,&fasuffixes[0]) + ".fa.tmp";
while ( ::libmaus::util::GetFileSize::fileExists(deftmpname) )
deftmpname += "_";
std::string defoutname = libmaus::util::OutputFileNameTools::endClipLcp(inputfilenames,&fasuffixes[0]) + ".fa.recoded";
while ( ::libmaus::util::GetFileSize::fileExists(defoutname) )
defoutname += "_";
std::string const tempfilename = arginfo.getValue<std::string>("tempfilename",deftmpname);
std::string const outfilename = arginfo.getValue<std::string>("outputfilename",defoutname);
std::string const indexfilename = tempfilename + ".index";
unsigned int const addterm = arginfo.getValue<unsigned int>("addterm",0);
unsigned int const termadd = addterm ? 1 : 0;
::libmaus::util::TempFileRemovalContainer::addTempFile(tempfilename);
::libmaus::util::TempFileRemovalContainer::addTempFile(indexfilename);
std::cerr << "temp file name " << tempfilename << std::endl;
std::cerr << "output file name " << outfilename << std::endl;
/* uint64_t const numseq = */ ::libmaus::fastx::FastAReader::rewriteFiles(inputfilenames,tempfilename,indexfilename);
uint64_t curpos = 0;
::libmaus::aio::CheckedOutputStream COS(outfilename);
// 0,A,C,G,T,N
// map forward
::libmaus::autoarray::AutoArray<char> cmap(256,false);
std::fill(cmap.begin(),cmap.end(),5+termadd);
cmap['\n'] = 0 + termadd;
cmap['a'] = cmap['A'] = 1 + termadd;
cmap['c'] = cmap['C'] = 2 + termadd;
cmap['g'] = cmap['G'] = 3 + termadd;
cmap['t'] = cmap['T'] = 4 + termadd;
cmap['n'] = cmap['N'] = 5 + termadd;
// map to reverse complement
::libmaus::autoarray::AutoArray<char> rmap(256,false);
std::fill(rmap.begin(),rmap.end(),5+termadd);
rmap['\n'] = 0 + termadd;
rmap['a'] = rmap['A'] = 4 + termadd;
rmap['c'] = rmap['C'] = 3 + termadd;
rmap['g'] = rmap['G'] = 2 + termadd;
rmap['t'] = rmap['T'] = 1 + termadd;
rmap['n'] = rmap['N'] = 5 + termadd;
// reverse complement for mapped data
::libmaus::autoarray::AutoArray<char> xmap(256,false);
std::fill(xmap.begin(),xmap.end(),5+termadd);
xmap[0] = 0 + termadd;
xmap[1] = 4 + termadd;
xmap[2] = 3 + termadd;
xmap[3] = 2 + termadd;
xmap[4] = 1 + termadd;
xmap[5] = 5 + termadd;
::libmaus::autoarray::AutoArray<char> imap(256,false);
for ( uint64_t i = 0; i < imap.size(); ++i )
imap[i] = static_cast<char>(i);
::libmaus::fastx::FastAReader::RewriteInfoDecoder::unique_ptr_type infodec(new ::libmaus::fastx::FastAReader::RewriteInfoDecoder(indexfilename));
::libmaus::fastx::FastAReader::RewriteInfo info;
uint64_t maxseqlen = 0;
while ( infodec->get(info) )
maxseqlen = std::max(maxseqlen,info.seqlen);
std::cerr << "[V] max seq len " << maxseqlen << std::endl;
::libmaus::fastx::FastAReader::RewriteInfoDecoder::unique_ptr_type tinfodec(new ::libmaus::fastx::FastAReader::RewriteInfoDecoder(indexfilename));
infodec = UNIQUE_PTR_MOVE(tinfodec);
if ( maxseqlen <= 256*1024 )
{
::libmaus::aio::CheckedInputStream CIS(tempfilename);
::libmaus::autoarray::AutoArray<uint8_t> B(maxseqlen+1,false);
while ( infodec->get(info) )
{
// skip id
CIS.ignore(info.idlen+2);
// read sequence plus following terminator
CIS.read(reinterpret_cast<char *>(B.begin()), info.seqlen+1);
// map
for ( uint64_t i = 0; i < info.seqlen+1; ++i )
B[i] = cmap[B[i]];
// write
COS.write(reinterpret_cast<char const *>(B.begin()),info.seqlen+1);
// remap
for ( uint64_t i = 0; i < info.seqlen+1; ++i )
B[i] = xmap[B[i]];
// reverse
std::reverse(B.begin(),B.begin()+info.seqlen);
// write
COS.write(reinterpret_cast<char const *>(B.begin()),info.seqlen+1);
}
}
else
{
while ( infodec->get(info) )
{
// std::cerr << info.valid << "\t" << info.idlen << "\t" << info.seqlen << "\t" << info.getIdPrefix() << std::endl;
uint64_t const seqbeg = curpos + (info.idlen+2);
uint64_t const seqend = seqbeg + info.seqlen;
::libmaus::aio::CheckedInputStream CIS(tempfilename); CIS.seekg(seqbeg);
::libmaus::util::GetFileSize::copyMap(CIS,COS,cmap.begin(),seqend-seqbeg+1);
::libmaus::aio::CircularReverseWrapper CRW(tempfilename,seqend);
::libmaus::util::GetFileSize::copyMap(CRW,COS,rmap.begin(),seqend-seqbeg+1);
curpos += (info.idlen+2) + (info.seqlen+1);
}
}
if ( addterm )
COS.put(0);
return EXIT_SUCCESS;
}
catch(std::exception const & ex)
{
std::cerr << ex.what() << std::endl;
return EXIT_FAILURE;
}
}
Tree reverseall (Tree l)
{
return isList(l) ? rmap(reverseall, l) : l;
}
Tree lmap (tfun f, Tree l)
{
return reverse(rmap(f,l));
}
//function(..) module saved jan 1 2013 as part of prep for scrt integration
static void function(Symbol f, Symbol caller[], Symbol callee[], int ncalls) {
int i, saved, sizefsave, sizeisave, varargs;
Symbol r, argregs[NUM_ARG_REGS];
usedmask[0] = usedmask[1] = 0;
freemask[0] = freemask[1] = ~(unsigned)0;
offset = maxoffset = maxargoffset = 0;
for (i = 0; callee[i]; i++) //find last argument
;
varargs = variadic(f->type) //see if variable arguments by type or by name of final argument
|| i > 0 && strcmp(callee[i-1]->name, "va_alist") == 0;
for (i = 0; callee[i]; i++) { //for each argument
Symbol p = callee[i];
Symbol q = caller[i];
assert(q);
offset = roundup(offset, q->type->align); //calculate the offset from the caller's sp
p->x.offset = q->x.offset = offset;
p->x.name = q->x.name = stringd(offset);
r = argreg(i, offset, optype(ttob(q->type)), q->type->size, optype(ttob(caller[0]->type)));
if (i < NUM_ARG_REGS)
argregs[i] = r;
offset = roundup(offset + q->type->size, 2); //i dunno
if (varargs)
p->sclass = AUTO; //variable args are always auto?
else if (r && ncalls == 0 && //I dunno
!isstruct(q->type) && !p->addressed &&
!(isfloat(q->type) && r->x.regnode->set == IREG)) {
p->sclass = q->sclass = REGISTER;
askregvar(p, r);
assert(p->x.regnode && p->x.regnode->vbl == p);
q->x = p->x;
q->type = p->type;
}
else if (askregvar(p, rmap(ttob(p->type)))
&& r != NULL
&& (isint(p->type) || p->type == q->type)) {
assert(q->sclass != REGISTER);
p->sclass = q->sclass = REGISTER;
q->type = p->type;
}
}
assert(!caller[i]); //done with arguments, their individual offsets and maxargoffset have been set
offset = 0;
gencode(caller, callee);
if (ncalls) //prepare to save return address if necessary(i.e. we do calls of our own)
usedmask[IREG] |= ((unsigned)1)<<REG_RETADDR;
usedmask[IREG] &= INT_CALLEE_SAVE; //limit saving to those we're responsible for
usedmask[FREG] &= 0xfff00000;
maxargoffset = roundup(maxargoffset, usedmask[FREG] ? 8 : 2);
if (ncalls && maxargoffset < NUM_ARG_REGS*2)
maxargoffset = NUM_ARG_REGS*2;
sizefsave = 4*bitcount(usedmask[FREG]); //space needed to save the float regs
sizeisave = 2*bitcount(usedmask[IREG]); //space needed to save the int regs
framesize = roundup(maxargoffset + sizefsave //space for outgoing arguments, space for saving floats,
+ sizeisave + maxoffset, 2); //space for saving ints, space for locals
//segment(CODE);
//printf("\talign 16\n");
printf("%s:\n", f->x.name);
i = maxargoffset + sizefsave - framesize; //I dunno but it's -v and it's never used!
if (framesize > 0)
print("\talu2I sp,sp,%d,smi,smbi\n", framesize);
saved = maxargoffset;
/space needed for outgoing arguments
void cv::cuda::meanShiftSegmentation(InputArray _src, OutputArray _dst, int sp, int sr, int minsize, TermCriteria criteria)
{
GpuMat src = _src.getGpuMat();
CV_Assert( src.type() == CV_8UC4 );
const int nrows = src.rows;
const int ncols = src.cols;
const int hr = sr;
const int hsp = sp;
// Perform mean shift procedure and obtain region and spatial maps
GpuMat d_rmap, d_spmap;
cuda::meanShiftProc(src, d_rmap, d_spmap, sp, sr, criteria);
Mat rmap(d_rmap);
Mat spmap(d_spmap);
Graph<SegmLinkVal> g(nrows * ncols, 4 * (nrows - 1) * (ncols - 1)
+ (nrows - 1) + (ncols - 1));
// Make region adjacent graph from image
Vec4b r1;
Vec4b r2[4];
Vec2s sp1;
Vec2s sp2[4];
int dr[4];
int dsp[4];
for (int y = 0; y < nrows - 1; ++y)
{
Vec4b* ry = rmap.ptr<Vec4b>(y);
Vec4b* ryp = rmap.ptr<Vec4b>(y + 1);
Vec2s* spy = spmap.ptr<Vec2s>(y);
Vec2s* spyp = spmap.ptr<Vec2s>(y + 1);
for (int x = 0; x < ncols - 1; ++x)
{
r1 = ry[x];
sp1 = spy[x];
r2[0] = ry[x + 1];
r2[1] = ryp[x];
r2[2] = ryp[x + 1];
r2[3] = ryp[x];
sp2[0] = spy[x + 1];
sp2[1] = spyp[x];
sp2[2] = spyp[x + 1];
sp2[3] = spyp[x];
dr[0] = dist2(r1, r2[0]);
dr[1] = dist2(r1, r2[1]);
dr[2] = dist2(r1, r2[2]);
dsp[0] = dist2(sp1, sp2[0]);
dsp[1] = dist2(sp1, sp2[1]);
dsp[2] = dist2(sp1, sp2[2]);
r1 = ry[x + 1];
sp1 = spy[x + 1];
dr[3] = dist2(r1, r2[3]);
dsp[3] = dist2(sp1, sp2[3]);
g.addEdge(pix(y, x, ncols), pix(y, x + 1, ncols), SegmLinkVal(dr[0], dsp[0]));
g.addEdge(pix(y, x, ncols), pix(y + 1, x, ncols), SegmLinkVal(dr[1], dsp[1]));
g.addEdge(pix(y, x, ncols), pix(y + 1, x + 1, ncols), SegmLinkVal(dr[2], dsp[2]));
g.addEdge(pix(y, x + 1, ncols), pix(y + 1, x, ncols), SegmLinkVal(dr[3], dsp[3]));
}
}
for (int y = 0; y < nrows - 1; ++y)
{
r1 = rmap.at<Vec4b>(y, ncols - 1);
r2[0] = rmap.at<Vec4b>(y + 1, ncols - 1);
sp1 = spmap.at<Vec2s>(y, ncols - 1);
sp2[0] = spmap.at<Vec2s>(y + 1, ncols - 1);
dr[0] = dist2(r1, r2[0]);
dsp[0] = dist2(sp1, sp2[0]);
g.addEdge(pix(y, ncols - 1, ncols), pix(y + 1, ncols - 1, ncols), SegmLinkVal(dr[0], dsp[0]));
}
for (int x = 0; x < ncols - 1; ++x)
{
r1 = rmap.at<Vec4b>(nrows - 1, x);
r2[0] = rmap.at<Vec4b>(nrows - 1, x + 1);
sp1 = spmap.at<Vec2s>(nrows - 1, x);
sp2[0] = spmap.at<Vec2s>(nrows - 1, x + 1);
dr[0] = dist2(r1, r2[0]);
dsp[0] = dist2(sp1, sp2[0]);
g.addEdge(pix(nrows - 1, x, ncols), pix(nrows - 1, x + 1, ncols), SegmLinkVal(dr[0], dsp[0]));
}
DjSets comps(g.numv);
// Find adjacent components
for (int v = 0; v < g.numv; ++v)
{
for (int e_it = g.start[v]; e_it != -1; e_it = g.edges[e_it].next)
{
int c1 = comps.find(v);
int c2 = comps.find(g.edges[e_it].to);
if (c1 != c2 && g.edges[e_it].val.dr < hr && g.edges[e_it].val.dsp < hsp)
comps.merge(c1, c2);
}
}
std::vector<SegmLink> edges;
edges.reserve(g.numv);
// Prepare edges connecting differnet components
for (int v = 0; v < g.numv; ++v)
{
int c1 = comps.find(v);
for (int e_it = g.start[v]; e_it != -1; e_it = g.edges[e_it].next)
{
int c2 = comps.find(g.edges[e_it].to);
if (c1 != c2)
edges.push_back(SegmLink(c1, c2, g.edges[e_it].val));
}
}
// Sort all graph's edges connecting differnet components (in asceding order)
std::sort(edges.begin(), edges.end());
// Exclude small components (starting from the nearest couple)
for (size_t i = 0; i < edges.size(); ++i)
{
int c1 = comps.find(edges[i].from);
int c2 = comps.find(edges[i].to);
if (c1 != c2 && (comps.size[c1] < minsize || comps.size[c2] < minsize))
comps.merge(c1, c2);
}
// Compute sum of the pixel's colors which are in the same segment
Mat h_src(src);
std::vector<Vec4i> sumcols(nrows * ncols, Vec4i(0, 0, 0, 0));
for (int y = 0; y < nrows; ++y)
{
Vec4b* h_srcy = h_src.ptr<Vec4b>(y);
for (int x = 0; x < ncols; ++x)
{
int parent = comps.find(pix(y, x, ncols));
Vec4b col = h_srcy[x];
Vec4i& sumcol = sumcols[parent];
sumcol[0] += col[0];
sumcol[1] += col[1];
sumcol[2] += col[2];
}
}
// Create final image, color of each segment is the average color of its pixels
_dst.create(src.size(), src.type());
Mat dst = _dst.getMat();
for (int y = 0; y < nrows; ++y)
{
Vec4b* dsty = dst.ptr<Vec4b>(y);
for (int x = 0; x < ncols; ++x)
{
int parent = comps.find(pix(y, x, ncols));
const Vec4i& sumcol = sumcols[parent];
Vec4b& dstcol = dsty[x];
dstcol[0] = static_cast<uchar>(sumcol[0] / comps.size[parent]);
dstcol[1] = static_cast<uchar>(sumcol[1] / comps.size[parent]);
dstcol[2] = static_cast<uchar>(sumcol[2] / comps.size[parent]);
dstcol[3] = 255;
}
}
}
