std::vector<std::string> get_directory_contents (const char* path) { std::vector<std::string> filenames; std::string patt(path); if (!patt.empty() && patt[patt.size() - 1] != '/' && patt[patt.size() - 1] != '\\') { patt.push_back('\\'); } patt.push_back('*'); WIN32_FIND_DATAA ffd; HANDLE h = FindFirstFileA(patt.c_str(), &ffd); if (h == INVALID_HANDLE_VALUE) { throw System_error("FindFirstFileA", patt, GetLastError()); } do { if (std::strcmp(ffd.cFileName, ".") != 0 && std::strcmp(ffd.cFileName, "..") != 0) { filenames.push_back(ffd.cFileName); } } while (FindNextFileA(h, &ffd) != 0); DWORD err = GetLastError(); if (err != ERROR_NO_MORE_FILES) { throw System_error("FileNextFileA", patt, err); } FindClose(h); return filenames; }
void dataset::calc_dist(REALNUM_TYPE rtDef, REALNUM_TYPE metricV, UNSIGNED_1B_TYPE metricKind) //metricKind: 0 - Euclidean, 1 - Cosine-based, 2 - Correlation coff, 3 - Tanimoto //all coefficients are turned into distances in a way of = 1 - (coff)^metricV { UNSIGNED_4B_TYPE i, i1, j, N = patt.RowNO(), D = patt.ColNO(); dist.SetSize(N, N); apvector<REALNUM_TYPE> V1(D), V2(D); for (i = 0; i < N; i++) { for (j = 0; j < D; j++) V1[j] = patt(i, j); dist(i,i) = rtDef; for (i1 = i + 1; i1 < N; i1++) { for (j = 0; j < D; j++) V2[j] = patt(i1, j); dist(i, i1) = dist(i1, i) = getMetricDistance(V1, V2, metricV, metricKind); }//for i1 }//for i calc_dist_pars(); }
TEST compile_REQ11() { mvCommand cmd; try { singletonParser.parse(cmd, REQ11); } catch (mvError* err) { FAIL(err); } mvQuery patt(cmd); ASSERT_STRREF(patt.classname, "person"); ASSERT_INT(patt.attrs.size(), 1); ASSERT_STRREF(patt.attrs[0].name, "name"); ASSERT_INT(patt.attrs[0].type, STRING); ASSERT_STRING(patt.attrs[0].value.string, "Umberto Eco"); }
int agg2RenderLineTiled(imageObj *img, shapeObj *p, imageObj * tile) { mapserver::pattern_filter_bilinear_rgba8 fltr; typedef mapserver::line_image_pattern<mapserver::pattern_filter_bilinear_rgba8> pattern_type; typedef mapserver::renderer_outline_image<renderer_base, pattern_type> renderer_img_type; typedef mapserver::rasterizer_outline_aa<renderer_img_type, mapserver::line_coord_sat> rasterizer_img_type; pattern_type patt(fltr); AGG2Renderer *r = AGG_RENDERER(img); AGG2Renderer *tileRenderer = AGG_RENDERER(tile); line_adaptor lines(p); patt.create(tileRenderer->m_pixel_format); renderer_img_type ren_img(r->m_renderer_base, patt); rasterizer_img_type ras_img(ren_img); ras_img.add_path(lines); return MS_SUCCESS; }
//retrieval bool dataset::load(istream& i, istream *i1, UNSIGNED_1B_TYPE mtxType) //mtxType = 0 (.xa file); = 1 (.x and .a files); = 2 (.svm file); = 10 (.x file only, no activities) //NB: descriptor labels should not contain blanks or tabs! //for extra-security, all reading in is done via string variable first { if ((mtxType == 1) && (i1 == NULL)) return false; // if activity file required, generate error STRING_TYPE xch = " ", axch = "\t", sx = " ", line; apvector<STRING_TYPE> lspl; char Bfr[20]; STRING_TYPE stBfr; SIGNED_4B_TYPE N, D, n, d, q, im0, im2; line.getlinewithtabs(i); line.parse_string(); line.replace(axch, xch); while (line.replace(sx, xch)); //treat consecutive delimiters as one SplitString(line, xch, lspl); if (lspl.length() < 2) return false; //--------------------------------------------------------------------------- if (mtxType == 2) {//SVM format, easier to handle separately N = 256; D = lspl.length() - 1; patt.SetSize(N, D); act.resize(N); n = 0; while (!i.eof()) { if (n == N) { N = n << 1; patt.SetSize(N, D); act.resize(N); } act[n] = atof(lspl[0].c_str()); for (d = 1; d < lspl.length(); d++) { im0 = lspl[d].find(':'); im2 = atoi(lspl[d].substr(0, im0).c_str()); stBfr = lspl[d].substr(im0+1, lspl[d].length()); if (im2 > D) { D = im2; patt.SetSize(N, D); } patt(n, im2 - 1) = atof(stBfr.c_str()); } n++; line.getlinewithtabs(i); line.parse_string(); line.replace(axch, xch); while (line.replace(sx, xch)); //treat consequtive delimitors as one SplitString(line, xch, lspl); if (lspl.length() < 2) break; };//while (!i.eof()) //only now true N and D are known - can generate SVM descriptor labels N = n; patt.SetSize(N, D); act.resize(N); sid.ids.resize(N); pid.resize(N); vars.Wipe(); vars.L.resize(D); for (n = 0; n < N; n++) { sprintf(Bfr, "SVMDATA%d", n+1); pid[n] = Bfr; pid[n].parse_string(); sid.ids[n] = pid[n]; sid.AddRecord(n); } for (d = 0; d < D; d++) { sprintf (Bfr, "SVMDSCR%d", d+1); vars.L[d] = Bfr; vars.L[d].parse_string(); vars.AddRecord(d); } sort_act(); dist.SetSize(0, 0); return true; }//if (mtxType == 2) //--------------------------------------------------------------------------- N = atoi(lspl[0].c_str()); D = atoi(lspl[1].c_str()); if ( (N < 1) || (D < 1) ) return false; dump(); //descriptors vars.L.resize(D); line.getlinewithtabs(i); line.parse_string(); line.replace(axch, xch); while (line.replace(sx, xch)); SplitString(line, xch, lspl); if (lspl.length() < D) {//allows to read first D data-fields only, fixed Dec 3 2009 dump(); return false; } if (lspl.length() > D) //May 2011 cout << "Warning, too many descriptor labels: " << lspl.length() << endl; for (d = 0; d < D; d++) { vars.L[d] = lspl[d]; vars.L[d].parse_string(); vars.AddRecord(d); } patt.SetSize(N, D); sid.ids.resize(N); pid.resize(N); //3 extra dimensions are seq#, ID and activity (only in a new format) act.resize(N); if (mtxType == 0) q = 3; else q = 2; for (n = 0; (n < N) && !i.eof(); n++) { do { line.getlinewithtabs(i); line.parse_string(); } while (line.length() == 0); //to skip empty lines within the matrix file line.replace(axch, xch); while (line.replace(sx, xch)); SplitString(line, xch, lspl); if (lspl.length() < (D + q)) break; if (lspl.length() > (D + q)) //May 2011 cout << "Line#" << n+1 << " has too many records: " << lspl[0] << " " << lspl[1] << " " << lspl[2] << " ..." << endl; pid[n] = lspl[0]; pid[n].parse_string(); sid.ids[n] = lspl[1]; if (mtxType == 0) act[n] = atof(lspl[2].c_str()); else { if ((i1 == NULL) || (mtxType == 10)) // if x-file only, then make up fake activities act[n] = 0; else {//can check for match with any of id columns in x-file (*i1) >> sid.ids[n]; (*i1) >> act[n]; } } sid.ids[n].parse_string(); sid.AddRecord(n); for (d = 0; d < D; d++) patt(n, d) = atof(lspl[d + q].c_str()); } if (n < N) { dump(); return false; } if (!i.eof()) {//read normalising data directly vars.B.resize(D); for (d = 0; (d < D) && !i.eof(); d++) i >> vars.B[d]; if (d == D) { vars.A.resize(D); for (d = 0; (d < D) && !i.eof(); d++) { i >> vars.A[d]; vars.A[d] -= vars.B[d]; }; if (d < D) { vars.A.resize(0); vars.B.resize(0); } }
virtual void on_draw() { pixfmt pf(rbuf_window()); renderer_base ren_base(pf); ren_base.clear(agg::rgba(1.0, 1.0, 0.95)); renderer_scanline ren(ren_base); rasterizer_scanline ras; scanline sl; // Pattern source. Must have an interface: // width() const // height() const // pixel(int x, int y) const // Any agg::renderer_base<> or derived // is good for the use as a source. //----------------------------------- pattern_src_brightness_to_alpha p1(rbuf_img(0)); pattern_src_brightness_to_alpha p2(rbuf_img(1)); pattern_src_brightness_to_alpha p3(rbuf_img(2)); pattern_src_brightness_to_alpha p4(rbuf_img(3)); pattern_src_brightness_to_alpha p5(rbuf_img(4)); pattern_src_brightness_to_alpha p6(rbuf_img(5)); pattern_src_brightness_to_alpha p7(rbuf_img(6)); pattern_src_brightness_to_alpha p8(rbuf_img(7)); pattern_src_brightness_to_alpha p9(rbuf_img(8)); agg::pattern_filter_bilinear_rgba<color_type> fltr; // Filtering functor // agg::line_image_pattern is the main container for the patterns. It creates // a copy of the patterns extended according to the needs of the filter. // agg::line_image_pattern can operate with arbitrary image width, but if the // width of the pattern is power of 2, it's better to use the modified // version agg::line_image_pattern_pow2 because it works about 15-25 percent // faster than agg::line_image_pattern (because of using simple masking instead // of expensive '%' operation). typedef agg::line_image_pattern<agg::pattern_filter_bilinear_rgba<color_type> > pattern_type; typedef agg::renderer_base<pixfmt> base_ren_type; typedef agg::renderer_outline_image<base_ren_type, pattern_type> renderer_type; typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type; //-- Create with specifying the source //pattern_type patt(fltr, src); //-- Create uninitialized and set the source pattern_type patt(fltr); renderer_type ren_img(ren_base, patt); rasterizer_type ras_img(ren_img); draw_curve(patt, ras_img, ren_img, p1, m_curve1.curve()); draw_curve(patt, ras_img, ren_img, p2, m_curve2.curve()); draw_curve(patt, ras_img, ren_img, p3, m_curve3.curve()); draw_curve(patt, ras_img, ren_img, p4, m_curve4.curve()); draw_curve(patt, ras_img, ren_img, p5, m_curve5.curve()); draw_curve(patt, ras_img, ren_img, p6, m_curve6.curve()); draw_curve(patt, ras_img, ren_img, p7, m_curve7.curve()); draw_curve(patt, ras_img, ren_img, p8, m_curve8.curve()); draw_curve(patt, ras_img, ren_img, p9, m_curve9.curve()); agg::render_ctrl(ras, sl, ren_base, m_curve1); agg::render_ctrl(ras, sl, ren_base, m_curve2); agg::render_ctrl(ras, sl, ren_base, m_curve3); agg::render_ctrl(ras, sl, ren_base, m_curve4); agg::render_ctrl(ras, sl, ren_base, m_curve5); agg::render_ctrl(ras, sl, ren_base, m_curve6); agg::render_ctrl(ras, sl, ren_base, m_curve7); agg::render_ctrl(ras, sl, ren_base, m_curve8); agg::render_ctrl(ras, sl, ren_base, m_curve9); agg::render_ctrl(ras, sl, ren_base, m_scale_x); agg::render_ctrl(ras, sl, ren_base, m_start_x); }
void nsFT2FontNode::GetFontNames(const char* aPattern, nsFontNodeArray* aNodes) { int j; PRBool rslt; PRUint32 count, i; char *pattern, *foundry, *family, *charset, *encoding; const char *charSetName; nsFontNode *node; nsCOMPtr<nsIArray> arrayFC; nsCAutoString familyTmp, languageTmp; FONT_CATALOG_PRINTF(("looking for FreeType font matching %s", aPattern)); nsCAutoString patt(aPattern); ToLowerCase(patt); pattern = strdup(patt.get()); NS_ASSERTION(pattern, "failed to copy pattern"); if (!pattern) goto cleanup_and_return; rslt = ParseXLFD(pattern, &foundry, &family, &charset, &encoding); if (!rslt) goto cleanup_and_return; // unable to handle "name-charset-*" if (charset && !encoding) { goto cleanup_and_return; } if (family) familyTmp.Assign(family); sFcs->GetFontCatalogEntries(familyTmp, languageTmp, 0, 0, 0, 0, getter_AddRefs(arrayFC)); if (!arrayFC) goto cleanup_and_return; arrayFC->GetLength(&count); for (i = 0; i < count; i++) { nsCOMPtr<nsITrueTypeFontCatalogEntry> fce = do_QueryElementAt(arrayFC, i); if (!fce) continue; nsCAutoString foundryName, familyName; PRUint32 flags, codePageRange1, codePageRange2; PRUint16 weight, width; fce->GetFamilyName(familyName); fce->GetFlags(&flags); fce->GetWidth(&width); fce->GetWeight(&weight); fce->GetCodePageRange1(&codePageRange1); fce->GetCodePageRange2(&codePageRange2); if (!charset) { // get all encoding FONT_CATALOG_PRINTF(("found FreeType %s-%s-*-*", foundryName.get(), familyName.get())); for (j=0; j<32; j++) { unsigned long bit = 1 << j; if (bit & codePageRange1) { charSetName = nsFreeType2::GetRange1CharSetName(bit); NS_ASSERTION(charSetName, "failed to get charset name"); if (!charSetName) continue; node = LoadNode(fce, charSetName, aNodes); } if (bit & codePageRange2) { charSetName = nsFreeType2::GetRange2CharSetName(bit); if (!charSetName) continue; LoadNode(fce, charSetName, aNodes); } } if (foundryName.IsEmpty() && !familyName.IsEmpty() && flags&FCE_FLAGS_SYMBOL) { // the "registry-encoding" is not used but LoadNode will fail without // some value for this LoadNode(fce, "symbol-fontspecific", aNodes); } } if (charset && encoding) { // get this specific encoding PRUint32 cpr1_bits, cpr2_bits; nsCAutoString charsetName(charset); charsetName.Append('-'); charsetName.Append(encoding); CharSetNameToCodeRangeBits(charsetName.get(), &cpr1_bits, &cpr2_bits); if (!(cpr1_bits & codePageRange1) && !(cpr2_bits & codePageRange2)) continue; FONT_CATALOG_PRINTF(("found FreeType -%s-%s-%s", familyName.get(),charset,encoding)); LoadNode(fce, charsetName.get(), aNodes); } } FREE_IF(pattern); return; cleanup_and_return: FONT_CATALOG_PRINTF(("nsFT2FontNode::GetFontNames failed")); FREE_IF(pattern); return; }
int main( int argc , char **argv ) { RDKit::ROMOL_SPTR mol1( RDKit::SmilesToMol( "c1ccccc1O" ) ); RDKit::RWMOL_SPTR patt( RDKit::SmartsToMol( "ccO" ) ); RDKit::MatchVectType res; if( RDKit::SubstructMatch( *mol1 , *patt , res ) ) { std::cout << "Pattern matched molecule : " << std::endl; for( size_t i = 0 ; i < res.size() ; ++i ) { std::cout << "(" << res[i].first << "," << res[i].second << ")"; } std::cout << std::endl; } std::vector<RDKit::MatchVectType> hits_vect; if( RDKit::SubstructMatch( *mol1 , *patt , hits_vect ) ) { for( size_t i = 0 ; i < hits_vect.size() ; ++i ) { std::cout << "Match " << i + 1 << " : "; for( size_t j = 0 ; j < hits_vect[i].size() ; ++j ) { std::cout << "(" << hits_vect[i][j].first << "," << hits_vect[i][j].second << ")"; } std::cout << std::endl; } } std::string file_root = getenv( "RDBASE" ); file_root += "/Docs/Book"; std::string sdf_file = file_root + "/data/actives_5ht3.sdf"; RDKit::SDMolSupplier mol_supplier( sdf_file , true ); RDKit::RWMOL_SPTR patt1( RDKit::SmartsToMol( "c[NH1]" ) ); std::vector<RDKit::ROMOL_SPTR> matches; while( !mol_supplier.atEnd() ) { RDKit::ROMOL_SPTR mol3( mol_supplier.next() ); if( mol3 && RDKit::SubstructMatch( *mol3 , *patt1 , res ) ) { matches.push_back( mol3 ); } } std::cout << "There were " << matches.size() << " hits in the file." << std::endl; RDKit::ROMOL_SPTR mol4( RDKit::SmilesToMol( "C1=CC=CC=C1OC" ) ); RDKit::RWMOL_SPTR smi_mol1( RDKit::SmilesToMol( "CO" ) ); if( RDKit::SubstructMatch( *mol4 , *smi_mol1 , res ) ) { std::cout << "SMILES match" << std::endl; } else { std::cout << "Not SMILES match" << std::endl; } RDKit::RWMOL_SPTR smt_mol1( RDKit::SmartsToMol( "CO" ) ); if( RDKit::SubstructMatch( *mol4 , *smt_mol1 , res ) ) { std::cout << "SMARTS match" << std::endl; } else { std::cout << "Not SMARTS match" << std::endl; } RDKit::RWMOL_SPTR smi_mol2( RDKit::SmilesToMol( "COC" ) ); if( RDKit::SubstructMatch( *mol4 , *smi_mol2 , res ) ) { std::cout << "SMILES match" << std::endl; } else { std::cout << "Not SMILES match" << std::endl; } RDKit::RWMOL_SPTR smt_mol2( RDKit::SmartsToMol( "COC" ) ); if( RDKit::SubstructMatch( *mol4 , *smt_mol2 , res ) ) { std::cout << "SMARTS match" << std::endl; } else { std::cout << "Not SMARTS match" << std::endl; } // Needs aromatic C RDKit::RWMOL_SPTR smt_mol3( RDKit::SmartsToMol( "COc" ) ); if( RDKit::SubstructMatch( *mol4 , *smt_mol3 , res ) ) { std::cout << "SMARTS match" << std::endl; } else { std::cout << "Not SMARTS match" << std::endl; } }
/** * This test checks various generic API methods in DecimalFormat to achieve 100% * API coverage. */ void IntlTestDecimalFormatAPI::testAPI(/*char *par*/) { UErrorCode status = U_ZERO_ERROR; // ======= Test constructors logln((UnicodeString)"Testing DecimalFormat constructors"); DecimalFormat def(status); if(U_FAILURE(status)) { errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status)); return; } // bug 10864 status = U_ZERO_ERROR; DecimalFormat noGrouping("###0.##", status); if (noGrouping.getGroupingSize() != 0) { errln("Grouping size should be 0 for no grouping."); } // end bug 10864 status = U_ZERO_ERROR; const UnicodeString pattern("#,##0.# FF"); DecimalFormat pat(pattern, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)"); return; } status = U_ZERO_ERROR; DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (French)"); return; } status = U_ZERO_ERROR; DecimalFormat cust1(pattern, symbols, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)"); } status = U_ZERO_ERROR; DecimalFormat cust2(pattern, *symbols, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols)"); } DecimalFormat copy(pat); // ======= Test clone(), assignment, and equality logln((UnicodeString)"Testing clone(), assignment and equality operators"); if( ! (copy == pat) || copy != pat) { errln((UnicodeString)"ERROR: Copy constructor or == failed"); } copy = cust1; if(copy != cust1) { errln((UnicodeString)"ERROR: Assignment (or !=) failed"); } Format *clone = def.clone(); if( ! (*clone == def) ) { errln((UnicodeString)"ERROR: Clone() failed"); } delete clone; // ======= Test various format() methods logln((UnicodeString)"Testing various format() methods"); double d = -10456.0037; int32_t l = 100000000; Formattable fD(d); Formattable fL(l); UnicodeString res1, res2, res3, res4; FieldPosition pos1(0), pos2(0), pos3(0), pos4(0); res1 = def.format(d, res1, pos1); logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1); res2 = pat.format(l, res2, pos2); logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2); status = U_ZERO_ERROR; res3 = cust1.format(fD, res3, pos3, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: format(Formattable [double]) failed"); } logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res3); status = U_ZERO_ERROR; res4 = cust2.format(fL, res4, pos4, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: format(Formattable [long]) failed"); } logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4); // ======= Test parse() logln((UnicodeString)"Testing parse()"); UnicodeString text("-10,456.0037"); Formattable result1, result2; ParsePosition pos(0); UnicodeString patt("#,##0.#"); status = U_ZERO_ERROR; pat.applyPattern(patt, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: applyPattern() failed"); } pat.parse(text, result1, pos); if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) { errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text); } logln(text + " parsed into " + (int32_t) result1.getDouble()); status = U_ZERO_ERROR; pat.parse(text, result2, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: parse() failed"); } if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) { errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text); } logln(text + " parsed into " + (int32_t) result2.getDouble()); // ======= Test getters and setters logln((UnicodeString)"Testing getters and setters"); const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols(); DecimalFormatSymbols *newSyms = new DecimalFormatSymbols(*syms); def.setDecimalFormatSymbols(*newSyms); def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this if( *(pat.getDecimalFormatSymbols()) != *(def.getDecimalFormatSymbols())) { errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed"); } UnicodeString posPrefix; pat.setPositivePrefix("+"); posPrefix = pat.getPositivePrefix(posPrefix); logln((UnicodeString)"Positive prefix (should be +): " + posPrefix); if(posPrefix != "+") { errln((UnicodeString)"ERROR: setPositivePrefix() failed"); } UnicodeString negPrefix; pat.setNegativePrefix("-"); negPrefix = pat.getNegativePrefix(negPrefix); logln((UnicodeString)"Negative prefix (should be -): " + negPrefix); if(negPrefix != "-") { errln((UnicodeString)"ERROR: setNegativePrefix() failed"); } UnicodeString posSuffix; pat.setPositiveSuffix("_"); posSuffix = pat.getPositiveSuffix(posSuffix); logln((UnicodeString)"Positive suffix (should be _): " + posSuffix); if(posSuffix != "_") { errln((UnicodeString)"ERROR: setPositiveSuffix() failed"); } UnicodeString negSuffix; pat.setNegativeSuffix("~"); negSuffix = pat.getNegativeSuffix(negSuffix); logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix); if(negSuffix != "~") { errln((UnicodeString)"ERROR: setNegativeSuffix() failed"); } int32_t multiplier = 0; pat.setMultiplier(8); multiplier = pat.getMultiplier(); logln((UnicodeString)"Multiplier (should be 8): " + multiplier); if(multiplier != 8) { errln((UnicodeString)"ERROR: setMultiplier() failed"); } int32_t groupingSize = 0; pat.setGroupingSize(2); groupingSize = pat.getGroupingSize(); logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSize); if(groupingSize != 2) { errln((UnicodeString)"ERROR: setGroupingSize() failed"); } pat.setDecimalSeparatorAlwaysShown(TRUE); UBool tf = pat.isDecimalSeparatorAlwaysShown(); logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " + (UnicodeString) (tf ? "TRUE" : "FALSE")); if(tf != TRUE) { errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed"); } // Added by Ken Liu testing set/isExponentSignAlwaysShown pat.setExponentSignAlwaysShown(TRUE); UBool esas = pat.isExponentSignAlwaysShown(); logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (UnicodeString) (esas ? "TRUE" : "FALSE")); if(esas != TRUE) { errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed"); } // Added by Ken Liu testing set/isScientificNotation pat.setScientificNotation(TRUE); UBool sn = pat.isScientificNotation(); logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE")); if(sn != TRUE) { errln((UnicodeString)"ERROR: setScientificNotation() failed"); } // Added by Ken Liu testing set/getMinimumExponentDigits int8_t MinimumExponentDigits = 0; pat.setMinimumExponentDigits(2); MinimumExponentDigits = pat.getMinimumExponentDigits(); logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits); if(MinimumExponentDigits != 2) { errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed"); } // Added by Ken Liu testing set/getRoundingIncrement double RoundingIncrement = 0.0; pat.setRoundingIncrement(2.0); RoundingIncrement = pat.getRoundingIncrement(); logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) RoundingIncrement); if(RoundingIncrement != 2.0) { errln((UnicodeString)"ERROR: setRoundingIncrement() failed"); } //end of Ken's Adding UnicodeString funkyPat; funkyPat = pat.toPattern(funkyPat); logln((UnicodeString)"Pattern is " + funkyPat); UnicodeString locPat; locPat = pat.toLocalizedPattern(locPat); logln((UnicodeString)"Localized pattern is " + locPat); // ======= Test applyPattern() logln((UnicodeString)"Testing applyPattern()"); UnicodeString p1("#,##0.0#;(#,##0.0#)"); logln((UnicodeString)"Applying pattern " + p1); status = U_ZERO_ERROR; pat.applyPattern(p1, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status); } UnicodeString s2; s2 = pat.toPattern(s2); logln((UnicodeString)"Extracted pattern is " + s2); if(s2 != p1) { errln((UnicodeString)"ERROR: toPattern() result did not match pattern applied"); } if(pat.getSecondaryGroupingSize() != 0) { errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSecondaryGroupingSize()); } if(pat.getGroupingSize() != 3) { errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize()); } UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)"); logln((UnicodeString)"Applying pattern " + p2); status = U_ZERO_ERROR; pat.applyLocalizedPattern(p2, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status); } UnicodeString s3; s3 = pat.toLocalizedPattern(s3); logln((UnicodeString)"Extracted pattern is " + s3); if(s3 != p2) { errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match pattern applied"); } status = U_ZERO_ERROR; UParseError pe; pat.applyLocalizedPattern(p2, pe, status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with " + (int32_t) status); } UnicodeString s4; s4 = pat.toLocalizedPattern(s3); logln((UnicodeString)"Extracted pattern is " + s4); if(s4 != p2) { errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result did not match pattern applied"); } if(pat.getSecondaryGroupingSize() != 2) { errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSecondaryGroupingSize()); } if(pat.getGroupingSize() != 3) { errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize()); } // ======= Test getStaticClassID() logln((UnicodeString)"Testing getStaticClassID()"); status = U_ZERO_ERROR; NumberFormat *test = new DecimalFormat(status); if(U_FAILURE(status)) { errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat"); } if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) { errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expected value"); } delete test; }
virtual void on_draw() { pixfmt pf(rbuf_window()); renderer_base ren_base(pf); ren_base.clear(agg::rgba(0.5, 0.75, 0.85)); renderer_scanline ren(ren_base); rasterizer_scanline ras; scanline sl; ras.clip_box(0, 0, width(), height()); // Pattern source. Must have an interface: // width() const // height() const // pixel(int x, int y) const // Any agg::renderer_base<> or derived // is good for the use as a source. //----------------------------------- pattern_src_brightness_to_alpha_rgba8 p1(rbuf_img(0)); agg::pattern_filter_bilinear_rgba8 fltr; // Filtering functor // agg::line_image_pattern is the main container for the patterns. It creates // a copy of the patterns extended according to the needs of the filter. // agg::line_image_pattern can operate with arbitrary image width, but if the // width of the pattern is power of 2, it's better to use the modified // version agg::line_image_pattern_pow2 because it works about 15-25 percent // faster than agg::line_image_pattern (because of using simple masking instead // of expensive '%' operation). typedef agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8> pattern_type; typedef agg::renderer_base<pixfmt> base_ren_type; typedef agg::renderer_outline_image<base_ren_type, pattern_type> renderer_img_type; typedef agg::rasterizer_outline_aa<renderer_img_type, agg::line_coord_sat> rasterizer_img_type; typedef agg::renderer_outline_aa<base_ren_type> renderer_line_type; typedef agg::rasterizer_outline_aa<renderer_line_type, agg::line_coord_sat> rasterizer_line_type; //-- Create with specifying the source //pattern_type patt(fltr, src); //-- Create uninitialized and set the source pattern_type patt(fltr); patt.create(p1); renderer_img_type ren_img(ren_base, patt); rasterizer_img_type ras_img(ren_img); //-- create uninitialized and set parameters agg::line_profile_aa profile; profile.smoother_width(10.0); //optional profile.width(8.0); //mandatory! renderer_line_type ren_line(ren_base, profile); ren_line.color(agg::rgba8(0,0,127)); //mandatory! rasterizer_line_type ras_line(ren_line); ras_line.round_cap(true); //optional //ras_line.line_join(agg::outline_no_join); //optional // Calculate the dilation value so that, the line caps were // drawn correctly. //--------------- double w2 = 9.0;//p1.height() / 2 + 2; // Set the clip box a bit bigger than you expect. You need it // to draw the clipped line caps correctly. The correct result // is achieved with raster clipping. //------------------------ ren_img.scale_x(m_scale_x.value()); ren_img.start_x(m_start_x.value()); ren_img.clip_box (50-w2, 50-w2, width()-50+w2, height()-50+w2); ren_line.clip_box(50-w2, 50-w2, width()-50+w2, height()-50+w2); // First, draw polyline without raster clipping just to show the idea //------------------------ draw_polyline(ras_line, ren_line, m_line1.polygon(), m_line1.num_points()); draw_polyline(ras_img, ren_img, m_line1.polygon(), m_line1.num_points()); // Clear the area, almost opaque, but not completely //------------------------ ren_base.blend_bar(0, 0, (int)width(), (int)height(), agg::rgba(1,1,1), 200); // Set the raster clip box and then, draw again. // In reality there shouldn't be two calls above. // It's done only for demonstration //------------------------ ren_base.clip_box((int)50, (int)50, (int)width()-50, (int)height()-50); // This "copy_bar" is also for demonstration only //------------------------ ren_base.copy_bar(0, 0, (int)width(), (int)height(), agg::rgba(1,1,1)); // Finally draw polyline correctly clipped: We use double clipping, // first is vector clipping, with extended clip box, second is raster // clipping with normal clip box. //------------------------ ren_img.scale_x(m_scale_x.value()); ren_img.start_x(m_start_x.value()); draw_polyline(ras_line, ren_line, m_line1.polygon(), m_line1.num_points()); draw_polyline(ras_img, ren_img, m_line1.polygon(), m_line1.num_points()); // Reset clipping and draw the controls and stuff ren_base.reset_clipping(true); m_line1.line_width(1/m_scale.scale()); m_line1.point_radius(5/m_scale.scale()); agg::render_ctrl(ras, sl, ren_base, m_line1); agg::render_ctrl(ras, sl, ren_base, m_scale_x); agg::render_ctrl(ras, sl, ren_base, m_start_x); char buf[256]; agg::gsv_text t; t.size(10.0); agg::conv_stroke<agg::gsv_text> pt(t); pt.width(1.5); pt.line_cap(agg::round_cap); const double* p = m_line1.polygon(); sprintf(buf, "Len=%.2f", agg::calc_distance(p[0], p[1], p[2], p[3]) * m_scale.scale()); t.start_point(10.0, 30.0); t.text(buf); ras.add_path(pt); ren.color(agg::rgba(0,0,0)); agg::render_scanlines(ras, sl, ren); }