void quaterN::transition0(const quater& aa, const quater& bb, int duration) { quater a(aa); quater b(bb); quater qid; qid.identity(); a.align(qid); b.align(qid); // kovar paper (prefer identity quaternion (more safe)) setSize(duration); float totalTime=duration+1; float currTime; quater c, d, qi; qi.identity(); for(int i=0; i<duration; i++) { currTime=(float)(i+1)/totalTime; float t=-2.f*CUBIC(currTime)+3.f*SQR(currTime); c.slerp(a, qi, t); d.slerp(qi, b, t); row(i).slerp(c, d, currTime); } }
static void validate_regex( const music_details& desc, int bells ) { static string allowed; if ( allowed.empty() ) { allowed.append( row(bells).print() ); allowed.append("*?[]"); } string tok( desc.get() ); if ( tok.find_first_not_of( allowed ) != string::npos ) throw runtime_error( make_string() << "Illegal regular expression: " << tok ); bool inbrack(false); for ( string::const_iterator i(tok.begin()), e(tok.end()); i!=e; ++i ) switch (*i) { case '[': if ( inbrack ) throw runtime_error( "Unexpected '[' in regular expressions" ); inbrack = true; break; case ']': if ( !inbrack ) throw runtime_error( "Unexpected ']' in regular expressions" ); inbrack = false; break; case '*': case '?': if ( inbrack ) throw runtime_error( "Cannot use '*' or '?' in a [] block " "of a regular expression" ); break; } // TODO: Check for multiple occurances of the same bell }
void SubsetSingleBench::onDraw(int n, SkCanvas* canvas) { // When the color type is kIndex8, we will need to store the color table. If it is // used, it will be initialized by the codec. int colorCount; SkPMColor colors[256]; if (fUseCodec) { for (int count = 0; count < n; count++) { SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(fStream->duplicate())); const SkImageInfo info = codec->getInfo().makeColorType(fColorType); SkAutoTDeleteArray<uint8_t> row(new uint8_t[info.minRowBytes()]); codec->startScanlineDecode(info, nullptr, colors, &colorCount); SkBitmap bitmap; SkImageInfo subsetInfo = info.makeWH(fSubsetWidth, fSubsetHeight); alloc_pixels(&bitmap, subsetInfo, colors, colorCount); codec->skipScanlines(fOffsetTop); uint32_t bpp = info.bytesPerPixel(); for (uint32_t y = 0; y < fSubsetHeight; y++) { codec->getScanlines(row.get(), 1, 0); memcpy(bitmap.getAddr(0, y), row.get() + fOffsetLeft * bpp, fSubsetWidth * bpp); } } } else { for (int count = 0; count < n; count++) { SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(fStream)); int width, height; decoder->buildTileIndex(fStream->duplicate(), &width, &height); SkBitmap bitmap; SkIRect rect = SkIRect::MakeXYWH(fOffsetLeft, fOffsetTop, fSubsetWidth, fSubsetHeight); decoder->decodeSubset(&bitmap, rect, fColorType); } } }
void EventView::mouseDoubleClickEvent(QMouseEvent *event) { QListWidgetItem *selectedItem = itemAt(event->pos()); if (selectedItem != NULL) { int selectedRow = row(selectedItem); if (!item(selectedRow)->text().contains(QRegExp("^\\s*::"))) { BaseEvent *eventToAdd = BaseEvent::browseEvents(currentEvent->getBaseType(), callerID, callerType); if (eventToAdd != NULL) { int row = currentRow(); int eventsID = childEventIDAtRow(row); int parentID = eventsParentIDAtRow(row); int childTypeID = childEventTypeIDAtRow(row); eventList[parentID]->addChildEvent(eventToAdd, eventsID, childTypeID); updateView(); eventList.clear(); eventList = currentEvent->getEventPointers(); setCurrentRow(row); } } } }
void SolverFormulacaoPadrao::UpdateConsUpperBound(double upper) { // constraint ConstraintFormulacaoPadrao cons; // variable VariableFormulacaoPadrao var; // creates the constraint cons.reset(); cons.set_type(ConstraintFormulacaoPadrao::C_UPPER_BOUND); ConstraintFormulacaoPadraoHash::iterator it = cHash_.find(cons); if (it == cHash_.end()) { cHash_[cons] = lp_->getNumRows(); int nnz = problem_data_->num_tasks(); OPT_ROW row(nnz, OPT_ROW::LESS, upper, (char*) cons.ToString().c_str()); // adds each variable for (int i = 0; i < problem_data_->num_machines(); ++i) { for (int j = 0; j < problem_data_->num_tasks(); ++j) { var.reset(); var.set_type(VariableFormulacaoPadrao::X_ij); var.set_machine(i); var.set_task(j); VariableFormulacaoPadraoHash::iterator vit = vHash_.find(var); //CHECK_NE(vit, vHash_.end()); double cost = problem_data_->cost(i, j); row.insert(vit->second, cost); } } lp_->addRow(row); } else { lp_->chgRHS(it->second, upper); } }
int main (int argc, char **argv){ int number; int height; int position = 2; int space = 0; int space2 =0; int space3 = 0; /*checking if there are arguments or if the argument is negative*/ if (argc == 1 || argv[1][0] == '-'){ return 0; } number = char_to_int(argv); /*Iterating though the first part of the cross*/ for(height = 0; height < number/2; height ++){ space = spaces(space); position = row(number, position); space2 = spaces2(space2); } /*Printing an x in the middle if the number is odd*/ if (number % 2 != 0){ space = spaces(space); write(1, "X", 1); space2 = spaces2(space2); space2 --; } space3 = space2; /*This is done so that the spaces before the symbles start form the middle of the second part of the cross*/ space = number/2 - 1; position -=1; for(height = 0; height < number/2; height ++){ space = spaces(space) - 2; position =row2(number, position); space3 = spaces3(space3); } return 0; }
void test_math_matrix_mult_TCRRMV(void) { T d1[M*N]; for(unsigned i=0; i<(M*N); ++i) { d1[i] = T(std::rand()%10000)/2; } T d2[N*K]; for(unsigned i=0; i<(N*K); ++i) { d2[i] = T(std::rand()%10000)/2; } auto m1 = eagine::math::matrix<T, N, M, RM1, V>::from(d1, M*N); auto m2 = eagine::math::matrix<T, K, N, RM2, V>::from(d2, N*K); eagine::math::matrix<T, K, M, RM1, V> m = multiply(m1, m2); (void)m; for(unsigned i=0; i<M; ++i) for(unsigned j=0; j<K; ++j) { T e = T(0); for(unsigned k=0; k<N; ++k) { e += row(m1, i)[k]*column(m2, j)[k]; } BOOST_CHECK_EQUAL(get_cm(m, j, i), e); BOOST_CHECK_EQUAL(get_rm(m, i, j), e); } }
void CUI_LoadMsg::draw(Drawable *S) { int i; char *str[] = { "Please wait, loading... |", "Please wait, loading... /", "Please wait, loading... -", "Please wait, loading... \\" }; if (S->lock()==0) { S->fillRect(col(15),row(20),640-col(15)-1,row(25)-1,COLORS.Background); printline(col(15),row(24),148,50,COLORS.Lowlight,S); for (i=20;i<25;i++) { printchar(col(15),row(i),145,COLORS.Highlight,S); printchar(col(64),row(i),146,COLORS.Lowlight,S); } printline(col(15),row(20),143,50,COLORS.Highlight,S); print(col(textcenter(str[strselect],40)),row(22),str[strselect],COLORS.Text,S); S->unlock(); need_refresh = 0; updated++; } }
PyObject *getEuclideanDistMat(python::object descripMat) { // Bit of a pain involved here, we accept three types of PyObjects here // 1. A Numeric Array // - first find what 'type' of entry we have (float, double and int is all we recognize for now) // - then point to contiguous piece of memory from the array that contains the data with a type* // - then make a new type** pointer so that double index into this contiguous memory will work // and then pass it along to the distance calculator // 2. A list of Numeric Vector (or 1D arrays) // - in this case wrap descripMat with a PySequenceHolder<type*> where type is the // type of entry in vector (accepted types are int, double and float // - Then pass the PySequenceHolder to the metrci calculator // 3. A list (or tuple) of lists (or tuple) // - In this case other than wrapping descripMat with a PySequenceHolder // each of the indivual list in there are also wrapped by a PySequenceHolder // - so the distance calculator is passed in a "PySequenceHolder<PySequenceHolder<double>>" // - FIX: not that we always convert entry values to double here, even if we passed // in a list of list of ints (or floats). Given that lists can be heterogeneous, I do not // know how to ask a list what type of entries if contains. // // OK my brain is going to explode now // first deal with situation where we have an Numeric Array PyObject *descMatObj = descripMat.ptr(); PyArrayObject *distRes; if (PyArray_Check(descMatObj)) { // get the dimensions of the array int nrows = ((PyArrayObject *)descMatObj)->dimensions[0]; int ncols = ((PyArrayObject *)descMatObj)->dimensions[1]; int i; CHECK_INVARIANT((nrows > 0) && (ncols > 0), ""); npy_intp dMatLen = nrows*(nrows-1)/2; // now that we have the dimensions declare the distance matrix which is always a // 1D double array distRes = (PyArrayObject *)PyArray_SimpleNew(1, &dMatLen, NPY_DOUBLE); // grab a pointer to the data in the array so that we can directly put values in there // and avoid copying : double *dMat = (double *)distRes->data; PyArrayObject *copy; copy = (PyArrayObject *)PyArray_ContiguousFromObject(descMatObj, ((PyArrayObject *)descMatObj)->descr->type_num, 2,2); // if we have double array if (((PyArrayObject *)descMatObj)->descr->type_num == NPY_DOUBLE) { double *desc = (double *)copy->data; // REVIEW: create an adaptor object to hold a double * and support // operator[]() so that we don't have to do this stuff: // here is the 2D array trick this so that when the distance calaculator // asks for desc2D[i] we basically get the ith row as double* double **desc2D = new double*[nrows]; for (i = 0; i < nrows; i++) { desc2D[i] = desc; desc += ncols; } MetricMatrixCalc<double**, double*> mmCalc; mmCalc.setMetricFunc(&EuclideanDistanceMetric<double *, double *>); mmCalc.calcMetricMatrix(desc2D, nrows, ncols, dMat); delete [] desc2D; // we got the distance matrix we are happy so return return PyArray_Return(distRes); } // if we have a float array else if (((PyArrayObject *)descMatObj)->descr->type_num == NPY_FLOAT) { float* desc = (float *)copy->data; float **desc2D = new float*[nrows]; for (i = 0; i < nrows; i++) { desc2D[i] = desc; desc += ncols; } MetricMatrixCalc<float**, float*> mmCalc; mmCalc.setMetricFunc(&EuclideanDistanceMetric<float *, float*>); mmCalc.calcMetricMatrix(desc2D, nrows, ncols, dMat); delete [] desc2D; return PyArray_Return(distRes); } // if we have an interger array else if (((PyArrayObject *)descMatObj)->descr->type_num == NPY_INT) { int *desc = (int *)copy->data; int **desc2D = new int*[nrows]; for (i = 0; i < nrows; i++) { desc2D[i] = desc; desc += ncols; } MetricMatrixCalc<int**, int*> mmCalc; mmCalc.setMetricFunc(&EuclideanDistanceMetric<int *, int*>); mmCalc.calcMetricMatrix(desc2D, nrows, ncols, dMat); delete [] desc2D; return PyArray_Return(distRes); } else { // unreconiged type for the matrix, throw up throw_value_error("The array has to be of type int, float, or double for GetEuclideanDistMat"); } } // done with an array input else { // REVIEW: removed a ton of code here // we have probably have a list or a tuple unsigned int ncols = 0; unsigned int nrows = python::extract<unsigned int>(descripMat.attr("__len__")()); CHECK_INVARIANT(nrows > 0, "Empty list passed in"); npy_intp dMatLen = nrows*(nrows-1)/2; distRes = (PyArrayObject *)PyArray_SimpleNew(1, &dMatLen, NPY_DOUBLE); double *dMat = (double *)distRes->data; // assume that we a have a list of list of values (that can be extracted to double) std::vector<PySequenceHolder<double> > dData; dData.reserve(nrows); for (unsigned int i = 0; i < nrows; i++) { //PySequenceHolder<double> row(seq[i]); PySequenceHolder<double> row(descripMat[i]); if(i==0) { ncols = row.size(); } else if( row.size() != ncols ) { throw_value_error("All subsequences must be the same length"); } dData.push_back(row); } MetricMatrixCalc< std::vector<PySequenceHolder<double> >, PySequenceHolder<double> > mmCalc; mmCalc.setMetricFunc(&EuclideanDistanceMetric< PySequenceHolder<double>, PySequenceHolder<double> >); mmCalc.calcMetricMatrix(dData, nrows, ncols, dMat); } return PyArray_Return(distRes); }
void InfoShape::draw(const DrawBuf &buf) const { if( !pane ) return; Smooth::DrawArt art(buf); VColor text=enable?+cfg.text:+cfg.inactive; Point space=+cfg.space; // decor { MPane p(pane); MCoord width=+cfg.width; MCoord dx=Fraction(space.x)-width; MCoord dy=Fraction(space.y)-width; if( focus ) { FigureBox fig(p.shrink(Fraction(space.x)/2,Fraction(space.y)/2)); fig.loop(art,width,+cfg.focus); } if( xoff>0 ) { FigureLeftMark fig(p,dx); fig.solid(art,text); } if( xoff<xoffMax ) { FigureRightMark fig(p,dx); fig.solid(art,text); } if( yoff>0 ) { FigureUpMark fig(p,dy); fig.solid(art,text); } if( yoff<yoffMax ) { FigureDownMark fig(p,dy); fig.solid(art,text); } } // text { Pane inner=pane.shrink(space); if( !inner ) return; ulen count=info->getLineCount(); ulen index=yoff; Font font=cfg.font.get(); FontSize fs=font->getSize(); DrawBuf tbuf=buf.cutRebase(inner); Pane row(-xoff,0,IntAdd(xoff,inner.dx),fs.dy); for(; index<count && row.y+row.dy<=inner.dy ;index++,row.y+=row.dy) { font->text(tbuf,row,TextPlace(AlignX_Left,AlignY_Top),info->getLine(index),text); } } }
std::pair<double,double> benchmark_spmv_ccsr( const vex::Context &ctx, vex::profiler<> &prof ) { // Construct matrix for 3D Poisson problem in cubic domain. const uint n = 128; const uint N = n * n * n; const uint M = 1024; double time_elapsed; const real h2i = (n - 1) * (n - 1); std::vector<size_t> idx; std::vector<size_t> row(3); std::vector<int> col(8); std::vector<real> val(8); std::vector<real> X(n * n * n, static_cast<real>(1e-2)); std::vector<real> Y(n * n * n, 0); idx.reserve(n * n * n); row[0] = 0; row[1] = 1; row[2] = 8; col[0] = 0; val[0] = 1; col[1] = -static_cast<int>(n * n); col[2] = -static_cast<int>(n); col[3] = -1; col[4] = 0; col[5] = 1; col[6] = n; col[7] = (n * n); val[1] = -h2i; val[2] = -h2i; val[3] = -h2i; val[4] = h2i * 6; val[5] = -h2i; val[6] = -h2i; val[7] = -h2i; for(size_t k = 0; k < n; k++) { for(size_t j = 0; j < n; j++) { for(size_t i = 0; i < n; i++) { if ( i == 0 || i == (n - 1) || j == 0 || j == (n - 1) || k == 0 || k == (n - 1) ) { idx.push_back(0); } else { idx.push_back(1); } } } } size_t nnz = 6 * (n - 2) * (n - 2) * (n - 2) + n * n * n; // Transfer data to compute devices. vex::SpMatCCSR<real,int> A(ctx.queue(0), n * n * n, 2, idx.data(), row.data(), col.data(), val.data()); std::vector<vex::command_queue> q1(1, ctx.queue(0)); vex::vector<real> x(q1, X); vex::vector<real> y(q1, Y); // Get timings. y += A * x; y = 0; prof.tic_cpu("OpenCL"); for(size_t i = 0; i < M; i++) y += A * x; ctx.finish(); time_elapsed = prof.toc("OpenCL"); double gflops = (2.0 * nnz + N) * M / time_elapsed / 1e9; double bwidth = M * (nnz * (2 * sizeof(real) + sizeof(int)) + 4 * N * sizeof(real)) / time_elapsed / 1e9; std::cout << "SpMV (CCSR) (" << vex::type_name<real>() << ")\n" << " OpenCL" << "\n GFLOPS: " << gflops << "\n Bandwidth: " << bwidth << std::endl; if (options.bm_cpu) { prof.tic_cpu("C++"); for(size_t k = 0; k < M; k++) for(size_t i = 0; i < N; i++) { real s = 0; for(size_t j = row[idx[i]]; j < row[idx[i] + 1]; j++) s += val[j] * X[i + col[j]]; Y[i] += s; } time_elapsed = prof.toc("C++"); { double gflops = (2.0 * nnz + N) * M / time_elapsed / 1e9; double bwidth = M * (nnz * (2 * sizeof(real) + sizeof(int)) + 4 * N * sizeof(real)) / time_elapsed / 1e9; std::cout << " C++" << "\n GFLOPS: " << gflops << "\n Bandwidth: " << bwidth << std::endl; } copy(Y, x); y -= x; vex::Reductor<real, vex::SUM> sum(q1); std::cout << " res = " << sum(y * y) << std::endl << std::endl; } return std::make_pair(gflops, bwidth); }
Vector4T<T>& operator[](int i) { return row(i); }
OP_STATUS ExtensionsManagerListViewItem::ConstructItemWidget(QuickWidget** widget) { *widget = NULL; // name_col OpAutoPtr<QuickStackLayout> name_col( OP_NEW(QuickStackLayout, (QuickStackLayout::VERTICAL))); RETURN_OOM_IF_NULL(name_col.get()); name_col->SetPreferredWidth(WidgetSizes::Fill); name_col->SetMinimumWidth(EXTENSION_NAME_MINIMUM_WIDTH); m_extension_name = ConstructName(); RETURN_OOM_IF_NULL(m_extension_name); RETURN_IF_ERROR(name_col->InsertWidget(m_extension_name)); m_author_version = ConstructAuthorAndVersion(); RETURN_OOM_IF_NULL(m_author_version); RETURN_IF_ERROR(name_col->InsertWidget(m_author_version)); // name_and_buttons_row OpAutoPtr<QuickStackLayout> name_and_buttons_row( OP_NEW(QuickStackLayout, (QuickStackLayout::HORIZONTAL))); RETURN_OOM_IF_NULL(name_and_buttons_row.get()); RETURN_IF_ERROR(name_and_buttons_row->InsertWidget(name_col.release())); QuickStackLayout* control_buttons = ConstructControlButtons(); RETURN_OOM_IF_NULL(control_buttons); RETURN_IF_ERROR(name_and_buttons_row->InsertWidget(control_buttons)); // main_col OpAutoPtr<QuickStackLayout> main_col( OP_NEW(QuickStackLayout, (QuickStackLayout::VERTICAL))); RETURN_OOM_IF_NULL(main_col.get()); RETURN_IF_ERROR(main_col->InsertWidget(name_and_buttons_row.release())); RETURN_IF_ERROR(main_col->InsertEmptyWidget(0, TEXT_SPACING, 0, TEXT_SPACING)); m_description = ConstructDescription(); RETURN_OOM_IF_NULL(m_description); RETURN_IF_ERROR(main_col->InsertWidget(m_description)); QuickStackLayout* debug_buttons = ConstructDebugButtons(); if (debug_buttons) { RETURN_IF_ERROR(main_col->InsertWidget(debug_buttons)); } // row_content OpAutoPtr<QuickStackLayout> row_content( OP_NEW(QuickStackLayout, (QuickStackLayout::HORIZONTAL))); RETURN_OOM_IF_NULL(row_content.get()); RETURN_IF_ERROR( row_content->InsertEmptyWidget(EXTENSION_ICON_PADDING, 0, EXTENSION_ICON_PADDING, 0)); m_icon = ConstructExtensionIcon(); RETURN_OOM_IF_NULL(m_icon); RETURN_IF_ERROR(row_content->InsertWidget(m_icon)); RETURN_IF_ERROR( row_content->InsertEmptyWidget(EXTENSION_ICON_PADDING, 0, EXTENSION_ICON_PADDING, 0)); RETURN_IF_ERROR(row_content->InsertWidget(main_col.release())); if (debug_buttons) { RETURN_IF_ERROR(row_content->InsertEmptyWidget(2, 0, 2, 0)); } // row OpAutoPtr<QuickStackLayout> row( OP_NEW(QuickStackLayout, (QuickStackLayout::VERTICAL))); RETURN_OOM_IF_NULL(row.get()); RETURN_IF_ERROR(row->InsertEmptyWidget(0, ROW_ITEM_TOP_PADDING, 0, ROW_ITEM_TOP_PADDING)); RETURN_IF_ERROR(row->InsertWidget(row_content.release())); RETURN_IF_ERROR(row->InsertEmptyWidget(0, ROW_ITEM_BOTTOM_PADDING, 0, ROW_ITEM_BOTTOM_PADDING)); QuickSkinElement *quick_skin_element = QuickSkinWrap(row.release(), "Extensions Panel List Item Skin"); RETURN_OOM_IF_NULL(quick_skin_element); quick_skin_element->GetOpWidget()->SetAlwaysHoverable(TRUE); *widget = quick_skin_element; UpdateControlButtonsState(); SetEnabled(!GetModelItem().IsDisabled()); return OpStatus::OK; }
shared_ptr<HtmlTableRow> HtmlTable::addRow() { shared_ptr<HtmlTableRow> row(OS_NEW HtmlTableRow()); getControls()->add(row); return row; }
const float4x4 float4x4::operator * (const float4x4& b) const { #if 1 // a textbook implementation... float4x4 c; const float4x4 &a = *this; for (int i = 1; i <= 4; ++i) { for (int k = 1; k <= 4; ++k) { c(i, k) = a(i, 1) * b(1, k) + a(i, 2) * b(2, k) + a(i, 3) * b(3, k) + a(i, 4) * b(4, k); } } return c; #else // assuredly slow, since row() does a lot of logic... return make_matrix(dot(row(0), m.c1), dot(row(0), m.c2), dot(row(0), m.c3), dot(row(0), m.c4), dot(row(1), m.c1), dot(row(1), m.c2), dot(row(1), m.c3), dot(row(1), m.c4), dot(row(2), m.c1), dot(row(2), m.c2), dot(row(2), m.c3), dot(row(2), m.c4), dot(row(3), m.c1), dot(row(3), m.c2), dot(row(3), m.c3), dot(row(3), m.c4)); #endif }
void SaveBitmapToFile( const char * fname, LVGrayDrawBuf * bmp ) { if (!bmp) return; LVStreamRef stream = LVOpenFileStream(fname, LVOM_WRITE); if (!stream) return; int rowsize = ((bmp->GetWidth()+1)/2); int img_size = rowsize * bmp->GetHeight(); int padding = rowsize - rowsize; BITMAPFILEHEADER fh; struct { BITMAPINFOHEADER hdr; RGBQUAD colors[16]; } bmi; memset(&fh, 0, sizeof(fh)); memset(&bmi, 0, sizeof(bmi)); fh.bfType = 0x4D42; fh.bfSize = sizeof(fh) + sizeof(bmi) + img_size; fh.bfOffBits = sizeof(fh) + sizeof(bmi); bmi.hdr.biSize = sizeof(bmi.hdr); bmi.hdr.biWidth = bmp->GetWidth(); bmi.hdr.biHeight = bmp->GetHeight(); bmi.hdr.biPlanes = 1; bmi.hdr.biBitCount = 4; bmi.hdr.biCompression = 0; bmi.hdr.biSizeImage = img_size; bmi.hdr.biXPelsPerMeter = 0xEC4; bmi.hdr.biYPelsPerMeter = 0xEC4; bmi.hdr.biClrUsed = 16; bmi.hdr.biClrImportant = 16; static lUInt8 gray[8] = { 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xAA, 0x55, 0x00 }; lUInt8 * pal = bmp->GetBitsPerPixel()==1?gray+0:gray+4; for (int i=0; i<4; i++) { bmi.colors[i].rgbBlue = pal[i]; bmi.colors[i].rgbGreen = pal[i]; bmi.colors[i].rgbRed = pal[i]; } stream->Write( &fh, sizeof(fh), NULL ); stream->Write( &bmi, sizeof(bmi), NULL ); static const lUInt8 dummy[3] = {0,0,0}; for (int y=0; y<bmp->GetHeight(); y++) { LVArray<lUInt8> row( (bmp->GetWidth()+1)/2, 0 ); for ( int x=0; x<bmp->GetWidth(); x++) { int cl = bmp->GetPixel(x, bmp->GetHeight()-1-y); //int cl = (src[x/8] >> ((1-(x&3))*2)) & 3; row[x/2] = row[x/2] | (cl << ((x&1)?0:4)); } row[0] = 0x11; row[1] = 0x11; row[2] = 0x22; row[3] = 0x22; row[4] = 0x33; row[5] = 0x33; *stream << row; if (padding) stream->Write( dummy, padding, NULL ); } }
void Fibre::Tractlet::Tensor::add_section_hessian( const Tractlet& tractlet, const Tractlet::Section& section, const Strand::BasicSection& gradient, const Strand::BasicSection::Tensor& hessian) { Fibre::Tractlet d2_intensity = get_template(); Strand pos_gradient = Strand::outer_product(section.position_coeffs, gradient.position() / section.intensity()); if (has_var_acs()) d2_intensity.set_acs(0.0); // d2_intensity.set_base_width(0.0); //Add position gradient. d2_intensity[0] += pos_gradient; d2_intensity[1] += pos_gradient * section.ax1_fraction; d2_intensity[2] += pos_gradient * section.ax2_fraction; //Add tangent gradient. Strand tang_gradient = Strand::outer_product(section.tangent_coeffs, gradient.tangent() * (section.length_fraction / section.intensity())); d2_intensity[0] += tang_gradient; d2_intensity[1] += tang_gradient * section.ax1_fraction; d2_intensity[2] += tang_gradient * section.ax2_fraction; Fibre::Tractlet acs_gradient = d2_intensity * section.intensity(); if (true) { //Needs some serious rewriting. throw Exception( "tied_width hessian needs to be adjusted after accounting for tractlet sheer."); double norm1 = tractlet[1][0].norm(); double norm2 = tractlet[2][0].norm(); Coord d_intensity_d1 = tractlet.acs() * ((norm2 / norm1) * tractlet(1, 0) - tractlet(2, 0)); Coord d_intensity_d2 = tractlet.acs() * ((norm1 / norm2) * tractlet(2, 0) - tractlet(1, 0)); for (size_t dim_i1 = 0; dim_i1 < 3; dim_i1++) { operator()(1, 0, dim_i1, 2, 0, dim_i1) -= gradient.intensity() * tractlet.acs(); operator()(2, 0, dim_i1, 1, 0, dim_i1) -= gradient.intensity() * tractlet.acs(); operator()(1, 0, dim_i1, 1, 0, dim_i1) += gradient.intensity() * tractlet.acs() * norm2 / norm1; operator()(2, 0, dim_i1, 2, 0, dim_i1) += gradient.intensity() * tractlet.acs() * norm1 / norm2; for (size_t dim_i2 = 0; dim_i2 < 3; dim_i2++) { operator()(1, 0, dim_i1, 1, 0, dim_i2) -= tractlet.acs() * gradient.intensity() * tractlet[1][0][dim_i1] * tractlet[1][0][dim_i2] * (norm2 / MR::Math::pow3(norm1)); operator()(2, 0, dim_i1, 2, 0, dim_i2) -= tractlet.acs() * gradient.intensity() * tractlet[2][0][dim_i1] * tractlet[2][0][dim_i2] * (norm1 / MR::Math::pow3(norm2)); operator()(1, 0, dim_i1, 2, 0, dim_i2) += tractlet.acs() * gradient.intensity() * tractlet[2][0][dim_i2] * tractlet[1][0][dim_i1] / (norm1 * norm2); operator()(2, 0, dim_i1, 1, 0, dim_i2) += tractlet.acs() * gradient.intensity() * tractlet[1][0][dim_i2] * tractlet[2][0][dim_i1] / (norm2 * norm1); for (size_t ax_i = 0; ax_i < 3; ++ax_i) for (size_t degree_i = 0; degree_i < tractlet.degree(); ++degree_i) { operator()(ax_i, degree_i, dim_i1, 1, 0, dim_i2) += tractlet.acs() * d2_intensity(ax_i, degree_i)[dim_i1] * d_intensity_d1[dim_i2]; operator()(ax_i, degree_i, dim_i1, 2, 0, dim_i2) += tractlet.acs() * d2_intensity(ax_i, degree_i)[dim_i1] * d_intensity_d2[dim_i2]; operator()(1, 0, dim_i1, ax_i, degree_i, dim_i2) += tractlet.acs() * d2_intensity(ax_i, degree_i)[dim_i2] * d_intensity_d1[dim_i1]; operator()(2, 0, dim_i1, ax_i, degree_i, dim_i2) += tractlet.acs() * d2_intensity(ax_i, degree_i)[dim_i2] * d_intensity_d2[dim_i1]; } } } if (has_var_acs()) { acs_gradient(1, 0) += gradient.intensity() * d_intensity_d1; acs_gradient(2, 0) += gradient.intensity() * d_intensity_d2; } } if (has_var_acs()) acs() += acs_gradient; for (size_t degree_i1 = 0; degree_i1 < degree(); degree_i1++) for (size_t dim_i1 = 0; dim_i1 < 3; dim_i1++) { Fibre::Tractlet ax0 = row(0, degree_i1, dim_i1); Fibre::Tractlet ax1 = row(1, degree_i1, dim_i1); Fibre::Tractlet ax2 = row(2, degree_i1, dim_i1); if (has_var_acs()) { ax0.alpha() += acs_gradient.operator()(0, degree_i1)[dim_i1]; ax1.alpha() += acs_gradient.operator()(1, degree_i1)[dim_i1]; ax2.alpha() += acs_gradient.operator()(2, degree_i1)[dim_i1]; } for (size_t degree_i2 = 0; degree_i2 < degree(); degree_i2++) for (size_t dim_i2 = 0; dim_i2 < 3; dim_i2++) { double ax0_ax0 = section.position_coeffs[degree_i1] * section.position_coeffs[degree_i2] * hessian.position(dim_i1).position(dim_i2) + section.position_coeffs[degree_i1] * section.tangent_coeffs[degree_i2] * hessian.position(dim_i1).tangent(dim_i2) * section.length_fraction + section.tangent_coeffs[degree_i1] * section.position_coeffs[degree_i2] * hessian.tangent(dim_i1).position(dim_i2) * section.length_fraction + section.tangent_coeffs[degree_i1] * section.tangent_coeffs[degree_i2] * hessian.tangent(dim_i1).tangent(dim_i2) * MR::Math::pow2(section.length_fraction); ax0[0][degree_i2][dim_i2] += ax0_ax0; ax0[1][degree_i2][dim_i2] += ax0_ax0 * section.ax1_fraction; ax1[0][degree_i2][dim_i2] += ax0_ax0 * section.ax1_fraction; ax0[2][degree_i2][dim_i2] += ax0_ax0 * section.ax2_fraction; ax2[0][degree_i2][dim_i2] += ax0_ax0 * section.ax2_fraction; ax1[1][degree_i2][dim_i2] += ax0_ax0 * MR::Math::pow2(section.ax1_fraction); ax1[2][degree_i2][dim_i2] += ax0_ax0 * section.ax1_fraction * section.ax2_fraction; ax2[1][degree_i2][dim_i2] += ax0_ax0 * section.ax1_fraction * section.ax2_fraction; ax2[2][degree_i2][dim_i2] += ax0_ax0 * MR::Math::pow2(section.ax2_fraction); } } }
void EffectRack::menuRequested(QListWidgetItem* it)/*{{{*/ { if (it == 0 || track == 0) return; RackSlot* curitem = (RackSlot*) it; Pipeline* epipe = track->efxPipe(); int idx = row(curitem); QString name; bool mute = false; bool nativeGui = false; Pipeline* pipe = track->efxPipe(); if (pipe) { name = pipe->name(idx); mute = (pipe->isActive(idx) == false); nativeGui = pipe->hasNativeGui(idx); } //enum { NEW, CHANGE, UP, DOWN, REMOVE, BYPASS, SHOW, SAVE }; enum { NEW, CHANGE, UP, DOWN, REMOVE, BYPASS, SHOW, SHOW_NATIVE, SAVE }; QMenu* menu = new QMenu; QAction* newAction = menu->addAction(tr("new")); QAction* changeAction = menu->addAction(tr("change")); QAction* upAction = menu->addAction(QIcon(*upIcon), tr("move up")); //, UP, UP); QAction* downAction = menu->addAction(QIcon(*downIcon), tr("move down")); //, DOWN, DOWN); QAction* removeAction = menu->addAction(tr("remove")); //, REMOVE, REMOVE); QAction* bypassAction = menu->addAction(tr("bypass")); //, BYPASS, BYPASS); QAction* showGuiAction = menu->addAction(tr("show gui")); //, SHOW, SHOW); QAction* showNativeGuiAction = menu->addAction(tr("show native gui")); //, SHOW_NATIVE, SHOW_NATIVE); QAction* saveAction = menu->addAction(tr("save preset")); newAction->setData(NEW); changeAction->setData(CHANGE); upAction->setData(UP); downAction->setData(DOWN); removeAction->setData(REMOVE); bypassAction->setData(BYPASS); showGuiAction->setData(SHOW); showNativeGuiAction->setData(SHOW_NATIVE); saveAction->setData(SAVE); bypassAction->setCheckable(true); showGuiAction->setCheckable(true); showNativeGuiAction->setCheckable(true); bypassAction->setChecked(mute); showGuiAction->setChecked(pipe->guiVisible(idx)); showNativeGuiAction->setEnabled(nativeGui); if (nativeGui) showNativeGuiAction->setChecked(pipe->nativeGuiVisible(idx)); if (pipe->empty(idx)) { menu->removeAction(changeAction); menu->removeAction(saveAction); upAction->setEnabled(false); downAction->setEnabled(false); removeAction->setEnabled(false); bypassAction->setEnabled(false); showGuiAction->setEnabled(false); showNativeGuiAction->setEnabled(false); } else { menu->removeAction(newAction); if (idx == 0) upAction->setEnabled(true); if (idx == ((int)epipe->size() - 1)) downAction->setEnabled(false); } QPoint pt = QCursor::pos(); QAction* act = menu->exec(pt, 0); //delete menu; if (!act) { delete menu; return; } int sel = act->data().toInt(); delete menu; int pdepth = epipe->size(); switch (sel) { case NEW: { choosePlugin(it); break; } case CHANGE: { choosePlugin(it, true); break; } case REMOVE: { BasePlugin* oldPlugin = (*epipe)[idx]; oldPlugin->setActive(false); oldPlugin->aboutToRemove(); if(debugMsg) qCritical("Plugin to remove now and here"); audio->msgAddPlugin(track, idx, 0); song->dirty = true; break; } case BYPASS: { bool flag = !pipe->isActive(idx); pipe->setActive(idx, flag); break; } case SHOW: { bool flag = !pipe->guiVisible(idx); pipe->showGui(idx, flag); break; } case SHOW_NATIVE: { printf("Show native GUI called\n"); bool flag = !pipe->nativeGuiVisible(idx); pipe->showNativeGui(idx, flag); break; } case UP: if (idx > 0) { setCurrentItem(item(idx - 1)); pipe->move(idx, true); } break; case DOWN: if (idx < pdepth) { setCurrentItem(item(idx + 1)); pipe->move(idx, false); } break; case SAVE: savePreset(idx); break; } //Already done on songChanged //updateContents(); song->update(SC_RACK); }/*}}}*/
int Image::write_png(char *file) const { if (_width == 0 || _height == 0 || _data == 0) { fprintf(stderr,"Image::write_png: image has no data"); return 0; } else if (_bpp < 1 || _bpp > 4) { fprintf(stderr,"Image::write_png: unsupported number of bytes/pixel (%d)", _bpp); return 0; } FILE* fp; if ((fp = fopen(file, "wb")) == 0) { fprintf(stderr,"Image::write_png: can't open file %s", file); return 0; } // Create and initialize the png_struct with the desired error handler // functions. If you want to use the default stderr and longjump method, // you can supply NULL for the last three parameters. We also check that // the library version is compatible with the one used at compile time, // in case we are using dynamically linked libraries. REQUIRED. png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0); if (!png_ptr) { fclose(fp); fprintf(stderr,"Image::write_png: png_create_write_struct() failed"); return 0; } // Allocate/initialize the image information data. REQUIRED png_infop info_ptr = png_create_info_struct(png_ptr); if (!info_ptr) { fclose(fp); png_destroy_write_struct(&png_ptr, (png_infopp)NULL); fprintf(stderr,"Image::write_png: png_create_info_struct() failed"); return 0; } // Set error handling if (setjmp(png_ptr->jmpbuf)) { // jump here from error encountered inside PNG code... // free all memory associated with the png_ptr and info_ptr fclose(fp); png_destroy_write_struct(&png_ptr, (png_infopp)NULL); fprintf(stderr,"Image::write_png: error writing file %s", file); return 0; } // Set up the input control (using standard C streams) // // see note re: C streams in read_png() above // png_init_io(png_ptr, fp); // set the image information: png_set_IHDR(png_ptr, info_ptr, _width, _height, 8, // bit depth ((_bpp==4) ? PNG_COLOR_TYPE_RGB_ALPHA : (_bpp==3) ? PNG_COLOR_TYPE_RGB : (_bpp==2) ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY), PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); // set gamma double gamma = getenv("JOT_GAMMA") ? atof(getenv("JOT_GAMMA")) : 0.45; png_set_gAMA(png_ptr, info_ptr, gamma); // write the file header information. REQUIRED png_write_info(png_ptr, info_ptr); // write the image data (inverted vertically): for (int y=_height-1; y>=0; y--) png_write_row(png_ptr, row(y)); // It is REQUIRED to call this to finish writing png_write_end(png_ptr, info_ptr); // clean up after the write, and free any memory allocated png_destroy_write_struct(&png_ptr, (png_infopp)NULL); // close the file fclose(fp); return 1; }
void EffectRack::dropEvent(QDropEvent *event)/*{{{*/ { event->accept(); QString text; QListWidgetItem *i = itemAt(event->pos()); if (!i) return; int idx = row(i); //qDebug("EffectRack::dropEvent: idx: %d", idx); Pipeline* pipe = track->efxPipe(); if (pipe) { //int size = pipe->size(); /*if (idx < size) { QWidget *sw = event->source(); if (sw) { if (strcmp(sw->metaObject()->className(), "EffectRack") == 0) { EffectRack *ser = (EffectRack*) sw; Pipeline* spipe = ser->getTrack()->efxPipe(); if (!spipe) return; QListWidgetItem *i = ser->itemAt(ser->getDragPos()); int idx0 = ser->row(i); if (!(*spipe)[idx0] || (idx == idx0 && (ser == this || ser->getTrack()->name() == track->name()))) return; } } if (QMessageBox::question(this, tr("Replace effect"), tr("Do you really want to replace the effect %1?").arg(pipe->name(idx)), QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes) { audio->msgAddPlugin(track, idx, 0); song->update(SC_RACK); } else { return; } }*/ if (event->mimeData()->hasFormat("text/x-oom-plugin")) { const QMimeData *md = event->mimeData(); QString outxml(md->data("text/x-oom-plugin")); //qDebug("EffectRack::dropEvent Event data:\n%s", outxml.toUtf8().constData()); //Xml xml(event->mimeData()->data("text/x-oom-plugin").data()); QByteArray ba = outxml.toUtf8(); const char* data = ba.constData(); Xml xml(data); initPlugin(xml, idx); } else if (event->mimeData()->hasUrls()) { // Multiple urls not supported here. Grab the first one. text = event->mimeData()->urls()[0].path(); if (text.endsWith(".pre", Qt::CaseInsensitive) || text.endsWith(".pre.gz", Qt::CaseInsensitive) || text.endsWith(".pre.bz2", Qt::CaseInsensitive)) { //bool popenFlag = false; bool popenFlag; FILE* fp = fileOpen(this, text, ".pre", "r", popenFlag, false, false); if (fp) { Xml xml(fp); initPlugin(xml, idx); if (popenFlag) pclose(fp); else fclose(fp); } } } } }/*}}}*/
void NetPrefsServerView::MessageReceived(BMessage* msg) { switch (msg->what) { case M_SERVER_ITEM_SELECTED: { BRow* row(fServerList->CurrentSelection()); if (row) { fEditButton->SetEnabled(true); fRemoveButton->SetEnabled(true); } else { fEditButton->SetEnabled(false); fRemoveButton->SetEnabled(false); } } break; case M_SERVER_ADD_ITEM: { BMessenger msgr(fEntryWin); if (msgr.IsValid()) fEntryWin->Activate(); else { fEntryWin = new ServerEntryWindow(this, new BMessage(M_SERVER_RECV_DATA), NULL, 0); fEntryWin->Show(); } } break; case M_SERVER_EDIT_ITEM: { BMessenger msgr(fEntryWin); if (msgr.IsValid()) fEntryWin->Activate(); else { BRow* row(fServerList->CurrentSelection()); if (!row) break; int32 count(0); ssize_t size(0); type_code type; fActiveNetwork->GetInfo("server", &type, &count); const ServerData* compData; for (int32 i = 0; i < count; i++) { fActiveNetwork->FindData("server", B_RAW_TYPE, i, reinterpret_cast<const void**>(&compData), &size); if (!strcmp(compData->serverName, ((BStringField*)row->GetField(1))->String())) break; } BMessage* invoke(new BMessage(M_SERVER_RECV_DATA)); invoke->AddBool("edit", true); fEntryWin = new ServerEntryWindow(this, invoke, compData, size); fEntryWin->Show(); } } break; case M_SERVER_REMOVE_ITEM: { RemoveServer(); fNetWin.SendMessage(M_SERVER_DATA_CHANGED); } break; case M_SERVER_RECV_DATA: { const ServerData* data; ssize_t size; Window()->DisableUpdates(); msg->FindData("server", B_RAW_TYPE, reinterpret_cast<const void**>(&data), &size); if (msg->HasBool("edit")) RemoveServer(); UpdateNetworkData(data); AddServer(data); Window()->EnableUpdates(); fNetWin.SendMessage(M_SERVER_DATA_CHANGED); } break; default: BView::MessageReceived(msg); break; } }
void initialize_new_objects(mpi::communicator& world, parameter_t const& P, directory_structure_t const& ds, geometric_info_t const& gi, object_info_t& oi, vector<std::vector<std::string> > const &seq, int tt, vector<CImg<unsigned char> > const& images, vector<matrix<float> > const& grd, vector<matrix<float> >& detected_rects) { int Ncam = seq.size(); vector<object_trj_t> & trlet_list=oi.trlet_list; int nobj = trlet_list.size(); int num_new_obj = detected_rects(0).size1(); int T = seq[0].size(); int np = oi.model.size(); int num_scales = P.scales.size(); //std::cout<<"detected_rects="<<detected_rects<<std::endl; for(int oo=0; oo<num_new_obj; ++oo) { int nn = oi.curr_num_obj + oo; trlet_list(nn).startt = tt; trlet_list(nn).endt = tt; trlet_list(nn).state = 1; trlet_list(nn).trj = vector<matrix<float> >(Ncam); for(int cam=0; cam<Ncam; ++cam) { trlet_list(nn).trj(cam) = scalar_matrix<float>(T, 4, 0); } trlet_list(nn).trj_3d = scalar_matrix<float>(T, 2, 0); trlet_list(nn).hist_p = vector<matrix<float> >(Ncam); trlet_list(nn).hist_q = vector<matrix<float> >(Ncam); trlet_list(nn).fscores = vector<matrix<float> >(Ncam); trlet_list(nn).scores = scalar_matrix<float>(Ncam, T, 0); vector<candidate_array<Float> > cand_array(Ncam); for(int cam=0; cam<Ncam; ++cam) { trlet_list(nn).fscores(cam) = scalar_matrix<float>(np*2, T, 0); float w = detected_rects(cam)(oo, 2)-detected_rects(cam)(oo, 0); float h = detected_rects(cam)(oo, 3)-detected_rects(cam)(oo, 1); row(trlet_list(nn).trj(cam), tt) = row(detected_rects(cam), oo); matrix<float> rects; compute_part_rects(detected_rects(cam)(oo, 0), detected_rects(cam)(oo, 1), w, h, oi.model, rects); pmodel_t pmodel; vector<float> br(row(detected_rects(cam), oo)); rects_to_pmodel_geom(br, gi.horiz_mean, pmodel); oi.pmodel_list(cam, nn) = pmodel; //collect_sift(grd(cam), ); matrix<float> hist_p, hist_q; collect_hist(images(cam), rects, hist_p, hist_q); trlet_list(nn).hist_p(cam) = hist_p; trlet_list(nn).hist_q(cam) = hist_q; matrix<Float> cand_rects; vector<Float> cand_scale; matrix<int> cand_ijs; if(0==world.rank()) { std::vector<float> sxr, syr; for(float v=-P.xrange/2; v<=P.xrange/2; v+=P.xstep) { sxr.push_back(v); } for(float v=-P.yrange/2; v<=P.yrange/2; v+=P.ystep) { syr.push_back(v); } vector<float> xr(sxr.size()), yr(syr.size()); std::copy(sxr.begin(), sxr.end(), xr.begin()); std::copy(syr.begin(), syr.end(), yr.begin()); float feetx = (trlet_list(nn).trj(cam)(tt, 0) +trlet_list(nn).trj(cam)(tt, 2))/2; float feety = trlet_list(nn).trj(cam)(tt, 3); enumerate_rects_inpoly(images(cam), oi.pmodel_list(cam, nn), feetx, feety, xr, yr, P.scales, gi.horiz_mean, gi.horiz_sig, gi.polys_im(tt, cam), cand_rects, cand_scale, cand_ijs, cand_array(cam)); } mpi::broadcast(world, cand_rects, 0); real_timer_t timer; vector<Float> cand_hist_score(cand_rects.size1()); matrix<Float> hist_fscores; range rrank(world.rank()*cand_rects.size1()/world.size(), (world.rank()+1)*cand_rects.size1()/world.size()); matrix<Float> cand_rects_rank(project(cand_rects, rrank, range(0, 4))); vector<Float> cand_hist_score_rank; matrix<Float> hist_fscores_rank; get_cand_hist_score(images(cam), oi.model, P.logp1, P.logp2, trlet_list(nn).hist_p(cam), trlet_list(nn).hist_q(cam), cand_rects_rank, cand_hist_score_rank, hist_fscores_rank); if(world.rank()==0) { std::vector<vector<Float> > v1; std::vector<matrix<Float> > v2; mpi::gather(world, cand_hist_score_rank, v1, 0); mpi::gather(world, hist_fscores_rank, v2, 0); hist_fscores = matrix<Float>(cand_rects.size1(), hist_fscores_rank.size2()); for(int r=0; r<world.size(); ++r) { int start = r*cand_rects.size1()/world.size(); for(int vv=0; vv<v1[r].size(); ++vv) { cand_hist_score(start+vv) = v1[r](vv); } for(int vv=0; vv<v2[r].size1(); ++vv) { row(hist_fscores, start+vv) = row(v2[r], vv); } } } else { mpi::gather(world, cand_hist_score_rank, 0); mpi::gather(world, hist_fscores_rank, 0); } mpi::broadcast(world, cand_hist_score, 0); mpi::broadcast(world, hist_fscores, 0); vector<Float> cand_score=cand_hist_score; if(0==world.rank()) std::cout<<"\t\t"<<cand_rects.size1()<<" rects, \tget_cand_hist_score time:" <<timer.elapsed()/1000.0f<<"s."<<std::endl; if(0==world.rank()) { int idx_max = std::max_element(cand_score.begin(), cand_score.end()) - cand_score.begin(); column(trlet_list(nn).fscores(cam), tt) = row(hist_fscores, idx_max); trlet_list(nn).scores(cam, tt) = cand_score(idx_max); cand_array(cam).fill_score(cand_score, cand_ijs); } mpi::broadcast(world, cand_array(cam), 0); mpi::broadcast(world, trlet_list(nn).scores(cam, tt), 0); vector<Float> fscore_col; if(0==world.rank()) { fscore_col = column(trlet_list(nn).fscores(cam), tt); } mpi::broadcast(world, fscore_col, 0); if(0!=world.rank()) { column(trlet_list(nn).fscores(cam), tt) = fscore_col; } }//end for cam int best_y, best_x, best_s; if(0==world.rank()) { ground_scoremap_t<Float> grd_scoremap; combine_ground_score(tt, cand_array, grd_scoremap, gi); grd_scoremap.peak(best_y, best_x, best_s); } mpi::broadcast(world, best_y, 0); mpi::broadcast(world, best_x, 0); trlet_list(nn).trj_3d(tt, 0) = best_x; trlet_list(nn).trj_3d(tt, 1) = best_y; for(int cam=0; cam<Ncam; ++cam) { vector<Float> trj_row(4); if(0==world.rank()) { vector<double> bx(1), by(1), ix, iy; bx <<= best_x; by <<= best_y; apply_homography(gi.grd2img(tt, cam), bx, by, ix, iy); float hpre = oi.pmodel_list(cam, nn).hpre; float cur_fy = iy(0); float cur_fx = ix(0); float cur_hy = gi.horiz_mean+hpre*(cur_fy-gi.horiz_mean); float ds = P.scales(best_s)*(cur_fy-cur_hy)/oi.pmodel_list(cam, nn).bh; float ww = ds*oi.pmodel_list(cam, nn).bw; float hh = cur_fy - cur_hy; trj_row <<= (cur_fx-ww/2), cur_hy, (cur_fx+ww/2), cur_fy; } mpi::broadcast(world, trj_row, 0); row(trlet_list(nn).trj(cam), tt) = trj_row; }//endfor cam }//endfor oo oi.curr_num_obj += num_new_obj; }
const Vector4T<T>& operator[](int i) const{ return row(i); }
void initialize_new_objects(parameter_t const& P, directory_structure_t const& ds, geometric_info_t const& gi, object_info_t& oi, vector<std::vector<std::string> > const &seq, int tt, vector<CImg<unsigned char> > const& images, vector<matrix<float> > const& grd, vector<matrix<float> >& detected_rects) { int Ncam = seq.size(); vector<object_trj_t> & trlet_list=oi.trlet_list; int nobj = trlet_list.size(); int num_new_obj = detected_rects(0).size1(); int T = seq[0].size(); int np = oi.model.size(); int num_scales = P.scales.size(); for(int oo=0; oo<num_new_obj; ++oo) { int nn = oi.curr_num_obj + oo; trlet_list(nn).startt = tt; trlet_list(nn).endt = tt; trlet_list(nn).state = 1; trlet_list(nn).trj = vector<matrix<float> >(Ncam); for(int cam=0; cam<Ncam; ++cam) { trlet_list(nn).trj(cam) = scalar_matrix<float>(T, 4, 0); } trlet_list(nn).trj_3d = scalar_matrix<float>(T, 2, 0); trlet_list(nn).hist_p = vector<matrix<float> >(Ncam); trlet_list(nn).hist_q = vector<matrix<float> >(Ncam); trlet_list(nn).fscores = vector<matrix<float> >(Ncam); trlet_list(nn).scores = scalar_matrix<float>(Ncam, T, 0); vector<candidate_array<Float> > cand_array(Ncam); for(int cam=0; cam<Ncam; ++cam) { trlet_list(nn).fscores(cam) = scalar_matrix<float>(np*2, T, 0); float w = detected_rects(cam)(oo, 2)-detected_rects(cam)(oo, 0); float h = detected_rects(cam)(oo, 3)-detected_rects(cam)(oo, 1); row(trlet_list(nn).trj(cam), tt) = row(detected_rects(cam), oo); matrix<float> rects; compute_part_rects(detected_rects(cam)(oo, 0), detected_rects(cam)(oo, 1), w, h, oi.model, rects); pmodel_t pmodel; vector<float> br(row(detected_rects(cam), oo)); rects_to_pmodel_geom(br, gi.horiz_mean, pmodel); oi.pmodel_list(cam, nn) = pmodel; //collect_sift(grd(cam), ); matrix<float> hist_p, hist_q; collect_hist(images(cam), rects, hist_p, hist_q); trlet_list(nn).hist_p(cam) = hist_p; trlet_list(nn).hist_q(cam) = hist_q; std::vector<float> sxr, syr; for(float v=-P.xrange/2; v<=P.xrange/2; v+=P.xstep) { sxr.push_back(v); } for(float v=-P.yrange/2; v<=P.yrange/2; v+=P.ystep) { syr.push_back(v); } vector<float> xr(sxr.size()), yr(syr.size()); std::copy(sxr.begin(), sxr.end(), xr.begin()); std::copy(syr.begin(), syr.end(), yr.begin()); float feetx = (trlet_list(nn).trj(cam)(tt, 0) +trlet_list(nn).trj(cam)(tt, 2))/2; float feety = trlet_list(nn).trj(cam)(tt, 3); matrix<Float> cand_rects; vector<Float> cand_scale; matrix<int> cand_ijs; enumerate_rects_inpoly(images(cam), oi.pmodel_list(cam, nn), feetx, feety, xr, yr, P.scales, gi.horiz_mean, gi.horiz_sig, gi.polys_im(cam), cand_rects, cand_scale, cand_ijs, cand_array(cam)); vector<Float> cand_hist_score; matrix<Float> hist_fscores; real_timer_t timer; get_cand_hist_score(images(cam), oi.model, P.logp1, P.logp2, trlet_list(nn).hist_p(cam), trlet_list(nn).hist_q(cam), cand_rects, cand_hist_score, hist_fscores); vector<Float> cand_score=cand_hist_score; std::cout<<"\t\t"<<cand_rects.size1()<<" rects, \tget_cand_hist_score time:" <<timer.elapsed()/1000.0f<<"s."<<std::endl; int idx_max = std::max_element(cand_score.begin(), cand_score.end()) - cand_score.begin(); column(trlet_list(nn).fscores(cam), tt) = row(hist_fscores, idx_max); trlet_list(nn).scores(cam, tt) = cand_score(idx_max); cand_array(cam).fill_score(cand_score, cand_ijs); }//end for cam real_timer_t timer; ground_scoremap_t<Float> grd_scoremap; combine_ground_score(cand_array, grd_scoremap, gi); int best_y, best_x, best_s; grd_scoremap.peak(best_y, best_x, best_s); for(int cam=0; cam<Ncam; ++cam) { vector<double> bx(1), by(1), ix, iy; bx <<= best_x; by <<= best_y; apply_homography(gi.grd2img(cam), bx, by, ix, iy); float hpre = oi.pmodel_list(cam, nn).hpre; float cur_fy = iy(0); float cur_fx = ix(0); float cur_hy = gi.horiz_mean+hpre*(cur_fy-gi.horiz_mean); float ds = P.scales(best_s)*(cur_fy-cur_hy)/oi.pmodel_list(cam, nn).bh; float ww = ds*oi.pmodel_list(cam, nn).bw; float hh = cur_fy - cur_hy; vector<Float> tmp(4); tmp <<= (cur_fx-ww/2), cur_hy, (cur_fx+ww/2), cur_fy; row(trlet_list(nn).trj(cam), tt) = tmp; //std::cout<<"trlet_list(nn).trj(cam)(tt, :)=" // <<row(trlet_list(nn).trj(cam), tt)<<std::endl; }//endfor cam }//endfor oo oi.curr_num_obj += num_new_obj; }
void Fsm::DumpState(yostream& s, size_t state) const { // Fill in a 'row': Q -> exp(V) (for current state) yvector< ybitset<MaxChar> > row(Size()); for (TransitionRow::const_iterator rit = m_transitions[state].begin(), rie = m_transitions[state].end(); rit != rie; ++rit) for (StatesSet::const_iterator sit = rit->second.begin(), sie = rit->second.end(); sit != sie; ++sit) { if (*sit >= Size()) { std::cerr << "WTF?! Transition from " << state << " on letter " << rit->first << " leads to non-existing state " << *sit << "\n"; YASSERT(false); } if (Letters().Contains(rit->first)) { const yvector<Char>& letters = Letters().Klass(Letters().Representative(rit->first)); for (yvector<Char>::const_iterator lit = letters.begin(), lie = letters.end(); lit != lie; ++lit) row[*sit].set(*lit); } else row[*sit].set(rit->first); } bool statePrinted = false; // Display each destination state for (yvector< ybitset<MaxChar> >::iterator rit = row.begin(), rie = row.end(); rit != rie; ++rit) { unsigned begin = 0, end = 0; ystring delimiter; ystring label; if (rit->test(Epsilon)) { label += delimiter + CharDump(Epsilon); delimiter = " "; } if (rit->test(BeginMark)) { label += delimiter + CharDump(BeginMark); delimiter = " "; } if (rit->test(EndMark)) { label += delimiter + CharDump(EndMark); delimiter = " "; } unsigned count = 0; for (unsigned i = 0; i < 256; ++i) if (rit->test(i)) ++count; if (count != 0 && count != 256) { label += delimiter + "["; bool complementary = (count > 128); if (count > 128) label += "^"; while (begin < 256) { for (begin = end; begin < 256 && (rit->test(begin) == complementary); ++begin) ; for (end = begin; end < 256 && (rit->test(end) == !complementary); ++end) ; if (begin + 1 == end) { label += CharDump(begin); delimiter = " "; } else if (begin != end) { label += CharDump(begin) + "-" + (CharDump(end-1)); delimiter = " "; } } label += "]"; delimiter = " "; } else if (count == 256) { label += delimiter + "."; delimiter = " "; } if (!label.empty()) { if (!statePrinted) { s << " " << state << "[shape=\"" << (IsFinal(state) ? "double" : "") << "circle\",label=\"" << state; Tags::const_iterator ti = tags.find(state); if (ti != tags.end()) s << " (tags: " << ti->second << ")"; s << "\"]\n"; if (Initial() == state) s << " \"initial\" -> " << state << '\n'; statePrinted = true; } s << " " << state << " -> " << std::distance(row.begin(), rit) << "[label=\"" << label; // Display outputs Outputs::const_iterator oit = outputs.find(state); if (oit != outputs.end()) { Outputs::value_type::second_type::const_iterator oit2 = oit->second.find(std::distance(row.begin(), rit)); if (oit2 == oit->second.end()) ; else { yvector<int> payload; for (unsigned i = 0; i < sizeof(oit2->second) * 8; ++i) if (oit2->second & (1ul << i)) payload.push_back(i); if (!payload.empty()) s << " (outputs: " << Join(payload.begin(), payload.end(), ", ") << ")"; } } s << "\"]\n"; } } if (statePrinted) s << '\n'; }
static gboolean ring_notify_show_text_message(ContactMethod *cm, const QModelIndex& idx) { g_return_val_if_fail(idx.isValid() && cm, FALSE); gboolean success = FALSE; auto title = g_markup_printf_escaped(C_("Text message notification", "%s says:"), idx.data(static_cast<int>(Ring::Role::Name)).toString().toUtf8().constData()); auto body = g_markup_escape_text(idx.data(Qt::DisplayRole).toString().toUtf8().constData(), -1); NotifyNotification *notification_new = nullptr; NotifyNotification *notification_old = nullptr; /* try to get the previous notification */ auto chat_table = ring_notify_get_chat_table(); auto list = (GList *)g_hash_table_lookup(chat_table, cm); if (list) notification_old = (NotifyNotification *)list->data; /* we display chat notifications in different ways to suit different notification servers and * their capabilities: * 1. if the server doesn't support appending (eg: Notification Daemon) then we update the * previous notification (if exists) with new text; otherwise it takes we have many * notifications from the same person... we don't concatinate the old messages because * servers which don't support append usually don't support multi line bodies * 2. the notify-osd server supports appending; however it doesn't clear the old notifications * on demand, which means in our case that chat messages which have already been read could * still be displayed when a new notification is appended, thus in this case, we update * the old notification body manually to only contain the unread messages * 3. the 3rd case is that the server supports append but is not notify-osd, then we simply use * the append feature */ if (notification_old && !server_info.append) { /* case 1 */ notify_notification_update(notification_old, title, body, nullptr); notification_new = notification_old; } else if (notification_old && g_strcmp0(server_info.name, SERVER_NOTIFY_OSD) == 0) { /* case 2 */ /* print up to MAX_NOTIFICATIONS unread messages */ int msg_count = 0; auto idx_next = idx.sibling(idx.row() - 1, idx.column()); auto read = idx_next.data(static_cast<int>(Media::TextRecording::Role::IsRead)).toBool(); while (idx_next.isValid() && !read && msg_count < MAX_NOTIFICATIONS) { auto body_prev = body; body = g_markup_printf_escaped("%s\n%s", body_prev, idx_next.data(Qt::DisplayRole).toString().toUtf8().constData()); g_free(body_prev); idx_next = idx_next.sibling(idx_next.row() - 1, idx_next.column()); read = idx_next.data(static_cast<int>(Media::TextRecording::Role::IsRead)).toBool(); ++msg_count; } notify_notification_update(notification_old, title, body, nullptr); notification_new = notification_old; } else { /* need new notification for case 1, 2, or 3 */ notification_new = notify_notification_new(title, body, nullptr); /* track in hash table */ auto list = (GList *)g_hash_table_lookup(chat_table, cm); list = g_list_append(list, notification_new); g_hash_table_replace(chat_table, cm, list); /* get photo */ QVariant var_p = GlobalInstances::pixmapManipulator().callPhoto( cm, QSize(50, 50), false); std::shared_ptr<GdkPixbuf> photo = var_p.value<std::shared_ptr<GdkPixbuf>>(); notify_notification_set_image_from_pixbuf(notification_new, photo.get()); /* normal priority for messages */ notify_notification_set_urgency(notification_new, NOTIFY_URGENCY_NORMAL); /* remove the key and value from the hash table once the notification is * closed; note that this will also unref the notification */ g_signal_connect(notification_new, "closed", G_CALLBACK(notification_closed), cm); /* if the notification server supports actions, make the default action to show the chat view */ if (server_info.actions) { notify_notification_add_action(notification_new, "default", C_("notification action name", "Show"), (NotifyActionCallback)ring_notify_show_cm, cm, nullptr); } } GError *error = nullptr; success = notify_notification_show(notification_new, &error); if (!success) { g_warning("failed to show notification: %s", error->message); g_clear_error(&error); } g_free(title); g_free(body); return success; }
void NormalEstimator::computePCA(cv::Mat& oVec, cv::Mat& eVec,cv::Mat& valVec){ // int dim = oVec.size().width; int oCnt = oVec.size().height; eVec = cv::Mat(dim,dim,CV_64FC1); valVec = cv::Mat(dim,1,CV_64FC1); //compute the mean cv::Mat row(1,dim,CV_64FC1); row = 0.0f; for (int i = 0; i < oCnt; i++) { row = row + oVec.row(i); } row /= oCnt; //for (int i = 0; i < dim; i++) //{ // std::cout << row.at<double>(0,i) << " " ; //} //std::cout << std::endl; //getchar(); //subtraction for (int i = 0; i < oCnt; i++) { for (int j = 0; j < dim; j++) { oVec.at<double>(i,j) = oVec.at<double>(i,j) - row.at<double>(0,j); } } // cv::Mat extProd(dim,dim,CV_64FC1); extProd = 0.0f; cv::Mat oVecT(dim,1,CV_64FC1); //for (int i = 0; i < oCnt; i++) //{ // for (int j = 0; j < dim; j++) // { // std::cout << oVec.at<double>(i,j) << " "; // } // std::cout << std::endl; //} //getchar(); for (int i = 0; i < oCnt; i++) { cv::transpose(oVec.row(i),oVecT); extProd = extProd + (oVecT * oVec.row(i)); ////print the product //for (int i1 = 0; i1 < dim ;i1++) //{ // for (int j1 = 0; j1 < dim; j1++) // { // std::cout << tmp.at<double>(i1,j1) << " "; // } // std::cout << std::endl; //} //getchar(); } extProd /= oCnt; //for (int i = 0; i < dim ;i++) //{ // for (int j = 0; j < dim; j++) // { // std::cout << extProd.at<double>(i,j) << " "; // } // std::cout << std::endl; //} //getchar(); cv::eigen(extProd,valVec,eVec); // }
/** * Get next token in the current string expr. * Uses the ExpParser data expr, e, token, t, token_type and err */ void ExpParser::getToken() { token_type = NOTHING; char* t; // points to a character in token t = token; // let t point to the first character in token *t = '\0'; // set token empty //printf("\tgetToken e:{%c}, ascii=%i, col=%i\n", *e, *e, e-expr); // skip over whitespaces while (*e == ' ' || *e == '\t') // space or tab { e++; } // check for end of expression if (*e == '\0') { // token is still empty token_type = DELIMETER; return; } // check for minus if (*e == '-') { token_type = DELIMETER; *t = *e; e++; t++; *t = '\0'; // add a null character at the end of token return; } // check for parentheses if (*e == '(' || *e == ')') { token_type = DELIMETER; *t = *e; e++; t++; *t = '\0'; return; } // check for operators (delimeters) if (isDelimeter(*e)) { token_type = DELIMETER; while (isDelimeter(*e)) { *t = *e; e++; t++; } *t = '\0'; // add a null character at the end of token return; } // check for a value if (isDigitDot(*e)) { token_type = NUMBER; while (isDigitDot(*e)) { *t = *e; e++; t++; } // check for scientific notation like "2.3e-4" or "1.23e50" if (toupper(*e) == 'E') { *t = *e; e++; t++; if (*e == '+' || *e == '-') { *t = *e; e++; t++; } while (isDigit(*e)) { *t = *e; e++; t++; } } *t = '\0'; return; } // check for variables or functions if (isAlpha(*e)) { while (isAlpha(*e) || isDigit(*e)) //while (isNotDelimeter(*e)) { *t = *e; e++; t++; } *t = '\0'; // add a null character at the end of token // check if this is a variable or a function. // a function has a parentesis '(' open after the name char* e2 = NULL; e2 = e; // skip whitespaces while (*e2 == ' ' || *e2 == '\t') // space or tab { e2++; } if (*e2 == '(') { token_type = FUNCTION; } else { token_type = VARIABLE; } return; } // something unknown is found, wrong characters -> a syntax error token_type = UNKNOWN; while (*e != '\0') { *t = *e; e++; t++; } *t = '\0'; throw Error(row(), col(), 1, token); return; }
MATHBASE_API void _JordanGaussCR( CDSRMMatrix<CDSRReal> *pA, CDSRMVector<CDSRReal> *pB, CDSRMVector<CDSRReal> *pX ) { if( pA->n_row() != pA->n_column() ) throw "The matrix is not square"; if( pA->n_row() != (long) pB->size() ) throw "Internal problem - sizes of the source and destination matrix are not equal"; long i, j, k; CDSRReal value; CDSRMMatrix<CDSRReal> matrix( (*pA) ); CDSRMVector<CDSRReal> vector( (*pB) ); CDSRMVector<long> row( pA->n_row() ); CDSRMVector<long> col( pA->n_row() ); pX->resize( pB->size() ); for( i = 0; i < pA->n_row(); i++ ) col[ i ] = row[ i ] = i; for( i = 0; i < pA->n_row(); i++ ) { if( IsNull( matrix( row[ i ], col[ i ] ) ) ) _IndexCR(i, &matrix, &row, &col ); for( k = i; k < pA->n_row(); k++ ) { value = matrix( row[ k ], col[ i ] ); if( IsNotNull( value ) && IsNotOne( value ) ) { vector[ row[ k ] ] /= value; for( j = i + 1; j < pA->n_row(); j++ ) matrix( row[ k ], col[ j ] ) /= value; matrix( row[ k ], col[ i ] ) = 1.0; } } for( k = i + 1; k < pA->n_row(); k++ ) { value = matrix( row[ k ], col[ i ] ); if( IsNotNull( value ) ) { vector[ row[ k ] ] -= vector[ row[ i ] ]; for( j = i + 1; j < pA->n_row(); j++ ) matrix( row[ k ], col[ j ] ) -= matrix( row[ i ], col[ j ] ); matrix( row[ k ], col[ i ] ) = 0.0; } } } for( i = pA->n_row() - 1; i > 0; i-- ) { for( k = 0; k < i + 1; k++ ) { value = matrix( row[ k ], col[ i ] ); if( IsNotNull( value ) && IsNotOne( value ) ) { vector[ row[ k ] ] /= value; for( j = k; j < i; j++ ) matrix( row[ k ], col[ j ] ) /= value; matrix( row[ k ], col[ i ] ) = 1.0; } } for( k = 0; k < i; k++ ) { value = matrix( row[ k ], col[ i ] ); if( IsNotNull( value ) ) { vector[ row[ k ] ] -= vector[ row[ i ] ]; matrix( row[ k ], col[ i ] ) = 0.0; } } } vector[ row[ 0 ] ] /= matrix( row[ 0 ], col[ 0 ] ); matrix( row[ 0 ], col[ 0 ] ) = 1.0; for( i = 0; i < pA->n_row(); i++ ) ( *pX )[ col[ i ] ] = vector[ row[ i ] ]; }
float Matrix4::determinant() const { // Determinant is the dot product of the first row and the first row // of cofactors (i.e. the first col of the adjoint matrix) return cofactor().row(0).dot(row(0)); }