void CurvesWidget::saveCurve(KConfigGroup& group, const QString& prefix) { kDebug() << "Storing curves"; for (int channel = 0; channel < ImageCurves::NUM_CHANNELS; ++channel) { group.writeEntry(CurvesWidgetPriv::getChannelTypeOption(prefix, channel), (int) curves()->getCurveType(channel)); for (int point = 0; point <= ImageCurves::NUM_POINTS; ++point) { QPoint p = curves()->getCurvePoint(channel, point); if (!isSixteenBits() && p != ImageCurves::getDisabledValue()) { // Store point as 16 bits depth. p.setX(p.x() * ImageCurves::MULTIPLIER_16BIT); p.setY(p.y() * ImageCurves::MULTIPLIER_16BIT); } group.writeEntry(CurvesWidgetPriv::getPointOption(prefix, channel, point), p); } } }
void CurvesWidget::restoreCurve(KConfigGroup& group, const QString& prefix) { kDebug() << "Restoring curves"; reset(); kDebug() << "curves " << curves() << " isSixteenBits = " << isSixteenBits(); for (int channel = 0; channel < ImageCurves::NUM_CHANNELS; ++channel) { curves()->setCurveType(channel, (ImageCurves::CurveType) group.readEntry( CurvesWidgetPriv::getChannelTypeOption( prefix, channel), 0)); for (int point = 0; point <= ImageCurves::NUM_POINTS; ++point) { QPoint p = group.readEntry(CurvesWidgetPriv::getPointOption(prefix, channel, point), ImageCurves::getDisabledValue()); // always load a 16 bit curve and stretch it to 8 bit if necessary if (!isSixteenBits() && p != ImageCurves::getDisabledValue()) { p.setX(p.x() / ImageCurves::MULTIPLIER_16BIT); p.setY(p.y() / ImageCurves::MULTIPLIER_16BIT); } curves()->setCurvePoint(channel, point, p); } curves()->curvesCalculateCurve(channel); } }
void animated_param_t::copy( const param_t& other, float offset, float start, float end) { param_t::copy( other); const animated_param_t *other_ = dynamic_cast<const animated_param_t*>( &other); for( int i = 0; i < curves().size(); ++i) curves()[i].copy( other_->curves()[i], offset, start, end); }
float animated_param_t::get_key_time( int nth) const { if( curves().size() == 1) return curves()[0][nth].time(); Loki::AssocVector<float, adobe::empty_t> key_times; fill_key_times_assoc_vector( key_times); return ( key_times.begin())[nth].first; }
int animated_param_t::get_num_keys() const { if( curves().size() == 1) return curves()[0].size(); // this is not very efficient. Loki::AssocVector<float, adobe::empty_t> key_times; fill_key_times_assoc_vector( key_times); return key_times.size(); }
adobe::any_regular_t float2_param_t::do_get_value_at_time( float time) const { Imath::V2f v( get_value<Imath::V2f>( *this)); if( !curves()[0].empty()) v.x = curves()[0].evaluate( time); if( !curves()[1].empty()) v.y = curves()[1].evaluate( time); return adobe::any_regular_t( v); }
Imath::V2f float2_param_t::derive( float time) const { Imath::V2f result( 0.0f, 0.0f); if( !curves()[0].empty()) result.x = curves()[0].derive( time); if( !curves()[1].empty()) result.y = curves()[1].derive( time); return result; }
void float2_param_t::do_create_tracks( anim::track_t *parent) { std::auto_ptr<anim::track_t> t( new anim::track_t( name())); std::auto_ptr<anim::track_t> tx( new anim::track_t( "X", &( curves()[0]))); tx->changed.connect( boost::bind( &animated_param_t::anim_curve_changed, this, _1)); t->add_child( tx); std::auto_ptr<anim::track_t> ty( new anim::track_t( "Y", &( curves()[1]))); ty->changed.connect( boost::bind( &animated_param_t::anim_curve_changed, this, _1)); t->add_child( ty); parent->add_child( t); }
Imath::V2f float2_param_t::integrate( float time1, float time2) const { Imath::V2f result = get_value<Imath::V2f>( *this); result.x = (time2 - time1) * result.x; result.y = (time2 - time1) * result.y; if( !curves()[0].empty()) result.x = curves()[0].integrate( time1, time2); if( !curves()[1].empty()) result.y = curves()[1].integrate( time1, time2); return result; }
void float2_param_t::set_value_at_time( const Imath::V2f& x, float time) { if( can_undo()) param_set()->add_command( this); value().assign( x); if( !is_static() && ( param_set()->autokey() || !curves()[0].empty())) curves()[0].insert( time, x.x); if( !is_static() && ( param_set()->autokey() || !curves()[1].empty())) curves()[1].insert( time, x.y); evaluate( time); param_set()->param_changed( this); }
bool BWConvert::toolOperations() { if (!loadToDImg()) { return false; } BWSepiaContainer prm; prm.filmType = settings()[QLatin1String("filmType")].toInt(); prm.filterType = settings()[QLatin1String("filterType")].toInt(); prm.toneType = settings()[QLatin1String("toneType")].toInt(); prm.bcgPrm.contrast = settings()[QLatin1String("contrast")].toDouble(); prm.strength = settings()[QLatin1String("strength")].toDouble(); CurvesContainer curves((ImageCurves::CurveType)settings()[QLatin1String("curvesType")].toInt(), true); curves.initialize(); curves.values[LuminosityChannel] = settings()[QLatin1String("curves")].value<QPolygon>(); prm.curvesPrm = curves; BWSepiaFilter bw(&image(), 0L, prm); applyFilter(&bw); return (savefromDImg()); }
void AdaptiveStretchCurveGraphInterface::__Click( Button& sender, bool checked ) { if ( sender == GUI->Render_ToolButton ) { ImageWindow window( m_width, m_height, 3, // numberOfChannels 8, // bitsPerSample false, // floating point true ); // color if ( !m_gridBitmap.IsNull() ) { View mainView = window.MainView(); ImageVariant v = mainView.Image(); static_cast<UInt8Image&>( *v ).Blend( m_gridBitmap ); if ( !m_curveBitmap.IsNull() ) static_cast<UInt8Image&>( *v ).Blend( m_curveBitmap ); } window.BringToFront(); window.Show(); window.ZoomToFit( false/*allowMagnification*/ ); } else if ( sender == GUI->Edit_ToolButton ) { CurvesTransformationInstance curves( TheCurvesTransformationProcess ); float ux = 1.0/(m_curve.Length() - 1); float m0 = 0; for ( int i = 0, j = 1; j < m_curve.Length(); ++j ) { float dy = Abs( m_curve[j] - m_curve[i] ); if ( dy > 0.01 ) { float dx = ux*(j - i); float m = dy/dx; if ( Abs( m - m0 )/m > 0.05 ) { m0 = m; i = j; curves[CurveIndex::RGBK].Add( ux*i, m_curve[i] ); } } else if ( 1 + dy == 1 ) { for ( ; ++j < m_curve.Length(); ++j ) { dy = Abs( m_curve[j] - m_curve[i] ); if ( 1 + dy > 1 ) { m0 = 0; i = j-1; curves[CurveIndex::RGBK].Add( ux*i, m_curve[i] ); break; } } } } curves.LaunchInterface(); } }
bool ON_Hatch::GetTightBoundingBox( ON_BoundingBox& tight_bbox, int bGrowBox, const ON_Xform* xform) const { int i; int count = m_loops.Count(); ON_CurveArray curves(count); for( i = 0; i < count; i++) { curves.Append( LoopCurve3d(i) ); } return curves.GetTightBoundingBox(tight_bbox,bGrowBox,xform); }
AlembicCurves::AlembicCurves(SceneNodePtr eNode, AlembicWriteJob * in_Job, Abc::OObject oParent) : AlembicObject(eNode, in_Job, oParent) { std::string xformName = EC_MCHAR_to_UTF8( mMaxNode->GetName() ); std::string curveName = xformName + "Shape"; AbcG::OCurves curves(GetOParent(),curveName,GetCurrentJob()->GetAnimatedTs()); mCurvesSchema = curves.getSchema(); // create all properties //mInTangentProperty = OV3fArrayProperty(mCurvesSchema.getArbGeomParams(), ".inTangent", mCurvesSchema.getMetaData(), GetCurrentJob()->GetAnimatedTs() ); //mOutTangentProperty = OV3fArrayProperty(mCurvesSchema.getArbGeomParams(), ".outTangent", mCurvesSchema.getMetaData(), GetCurrentJob()->GetAnimatedTs() ); //mRadiusProperty = OFloatArrayProperty(mCurvesSchema.getArbGeomParams(), ".radius", mCurvesSchema.getMetaData(), GetCurrentJob()->GetAnimatedTs() ); //mColorProperty = OC4fArrayProperty(mCurvesSchema.getArbGeomParams(), ".color", mCurvesSchema.getMetaData(), GetCurrentJob()->GetAnimatedTs() ); }
void BWSepiaFilter::filterImage() { if (d->settings.preview) { m_destImage = getThumbnailForEffect(m_orgImage); } else { m_destImage = m_orgImage; postProgress(10); // Apply black and white filter. blackAndWhiteConversion(m_destImage, d->settings.filterType); postProgress(20); // Apply black and white film type. blackAndWhiteConversion(m_destImage, d->settings.filmType); postProgress(30); // Apply color tone filter. blackAndWhiteConversion(m_destImage, d->settings.toneType); postProgress(40); // Calculate and apply the luminosity curve on image. CurvesFilter curves(&m_destImage, 0L, d->settings.curvesPrm); postProgress(50); curves.startFilterDirectly(); postProgress(60); m_destImage.putImageData(curves.getTargetImage().bits()); postProgress(70); // Adjust contrast. BCGFilter bcg(&m_destImage, 0L, d->settings.bcgPrm); postProgress(80); bcg.startFilterDirectly(); postProgress(90); m_destImage.putImageData(bcg.getTargetImage().bits()); postProgress(100); } }
void Controller::displayDensityCurves(int x, int y) { SteerableViewMap * svm = _Canvas->getSteerableViewMap(); if (!svm) return; unsigned int i, j; typedef vector<Vec3r> densityCurve; vector<densityCurve> curves(svm->getNumberOfOrientations() + 1); vector<densityCurve> curvesDirection(svm->getNumberOfPyramidLevels()); // collect the curves values unsigned nbCurves = svm->getNumberOfOrientations() + 1; unsigned nbPoints = svm->getNumberOfPyramidLevels(); if (!nbPoints) return; // build the density/nbLevels curves for each orientation for (i = 0; i < nbCurves; ++i) { for (j = 0; j < nbPoints; ++j) { curves[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(i, j, x, y), 0)); } } // build the density/nbOrientations curves for each level for (i = 0; i < nbPoints; ++i) { for (j = 0; j < nbCurves; ++j) { curvesDirection[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(j, i, x, y), 0)); } } // display the curves #if 0 for (i = 0; i < nbCurves; ++i) _pDensityCurvesWindow->setOrientationCurve(i, Vec2d(0, 0), Vec2d(nbPoints, 1), curves[i], "scale", "density"); for (i = 1; i <= 8; ++i) _pDensityCurvesWindow->setLevelCurve(i, Vec2d(0, 0), Vec2d(nbCurves, 1), curvesDirection[i], "orientation", "density"); _pDensityCurvesWindow->show(); #endif }
void RawProcessingFilter::filterImage() { m_destImage = m_orgImage; // emulate LibRaw custom output profile if (!m_customOutputProfile.isNull()) { // Note the m_destImage is not yet ready in load()! IccTransform trans; trans.setIntent(IccTransform::Perceptual); trans.setEmbeddedProfile(m_destImage); trans.setOutputProfile(m_customOutputProfile); trans.apply(m_orgImage, m_observer); m_destImage.setIccProfile(m_customOutputProfile); } postProgress(20); if (!m_settings.wb.isDefault()) { WBFilter wb(m_settings.wb, this, m_orgImage, m_destImage, 20, 40); } postProgress(40); if (!m_settings.bcg.isDefault()) { BCGFilter bcg(m_settings.bcg, this, m_orgImage, m_destImage, 40, 70); } postProgress(70); if (!m_settings.curvesAdjust.isEmpty()) { CurvesFilter curves(m_settings.curvesAdjust, this, m_orgImage, m_destImage, 70, 100); } postProgress(100); }
//-***************************************************************************** IObjectDrw::IObjectDrw( IObject &iObj, bool iResetIfNoChildren ) : m_object( iObj ) , m_minTime( ( chrono_t )FLT_MAX ) , m_maxTime( ( chrono_t )-FLT_MAX ) { // If not valid, just bail. if ( !m_object ) { return; } // IObject has no explicit time sampling, but its children may. size_t numChildren = m_object.getNumChildren(); for ( size_t i = 0; i < numChildren; ++i ) { const ObjectHeader &ohead = m_object.getChildHeader( i ); // Decide what to make. DrawablePtr dptr; if ( IPolyMesh::matches( ohead ) ) { IPolyMesh pmesh( m_object, ohead.getName() ); if ( pmesh ) { dptr.reset( new IPolyMeshDrw( pmesh ) ); } } else if ( IPoints::matches( ohead ) ) { IPoints points( m_object, ohead.getName() ); if ( points ) { dptr.reset( new IPointsDrw( points ) ); } } else if ( ICurves::matches( ohead ) ) { ICurves curves( m_object, ohead.getName() ); if ( curves ) { dptr.reset( new ICurvesDrw( curves ) ); } } else if ( INuPatch::matches( ohead ) ) { INuPatch nuPatch( m_object, ohead.getName() ); if ( nuPatch ) { dptr.reset( new INuPatchDrw( nuPatch ) ); } } else if ( IXform::matches( ohead ) ) { IXform xform( m_object, ohead.getName() ); if ( xform ) { dptr.reset( new IXformDrw( xform ) ); } } else if ( ISubD::matches( ohead ) ) { ISubD subd( m_object, ohead.getName() ); if ( subd ) { dptr.reset( new ISubDDrw( subd ) ); } } else { IObject object( m_object, ohead.getName() ); if ( object ) { dptr.reset( new IObjectDrw( object, true ) ); } } if ( dptr && dptr->valid() ) { m_children.push_back( dptr ); m_minTime = std::min( m_minTime, dptr->getMinTime() ); m_maxTime = std::max( m_maxTime, dptr->getMaxTime() ); } } // Make the bounds empty to start m_bounds.makeEmpty(); // If we have no children, just leave. if ( m_children.size() == 0 && iResetIfNoChildren ) { m_object.reset(); } }
void tst_QPainterPath::closing() { // lineto's { QPainterPath triangle(QPoint(100, 100)); triangle.lineTo(200, 100); triangle.lineTo(200, 200); QCOMPARE(triangle.elementCount(), 3); triangle.closeSubpath(); QCOMPARE(triangle.elementCount(), 4); QCOMPARE(triangle.elementAt(3).type, QPainterPath::LineToElement); triangle.moveTo(300, 300); QCOMPARE(triangle.elementCount(), 5); QCOMPARE(triangle.elementAt(4).type, QPainterPath::MoveToElement); triangle.lineTo(400, 300); triangle.lineTo(400, 400); QCOMPARE(triangle.elementCount(), 7); triangle.closeSubpath(); QCOMPARE(triangle.elementCount(), 8); // this will should trigger implicit moveto... triangle.lineTo(600, 300); QCOMPARE(triangle.elementCount(), 10); QCOMPARE(triangle.elementAt(8).type, QPainterPath::MoveToElement); QCOMPARE(triangle.elementAt(9).type, QPainterPath::LineToElement); triangle.lineTo(600, 700); QCOMPARE(triangle.elementCount(), 11); } // curveto's { QPainterPath curves(QPoint(100, 100)); curves.cubicTo(200, 100, 100, 200, 200, 200); QCOMPARE(curves.elementCount(), 4); curves.closeSubpath(); QCOMPARE(curves.elementCount(), 5); QCOMPARE(curves.elementAt(4).type, QPainterPath::LineToElement); curves.moveTo(300, 300); QCOMPARE(curves.elementCount(), 6); QCOMPARE(curves.elementAt(5).type, QPainterPath::MoveToElement); curves.cubicTo(400, 300, 300, 400, 400, 400); QCOMPARE(curves.elementCount(), 9); curves.closeSubpath(); QCOMPARE(curves.elementCount(), 10); // should trigger implicit moveto.. curves.cubicTo(100, 800, 800, 100, 800, 800); QCOMPARE(curves.elementCount(), 14); QCOMPARE(curves.elementAt(10).type, QPainterPath::MoveToElement); QCOMPARE(curves.elementAt(11).type, QPainterPath::CurveToElement); } { QPainterPath rects; rects.addRect(100, 100, 100, 100); QCOMPARE(rects.elementCount(), 5); QCOMPARE(rects.elementAt(0).type, QPainterPath::MoveToElement); QCOMPARE(rects.elementAt(4).type, QPainterPath::LineToElement); rects.addRect(300, 100, 100,100); QCOMPARE(rects.elementCount(), 10); QCOMPARE(rects.elementAt(5).type, QPainterPath::MoveToElement); QCOMPARE(rects.elementAt(9).type, QPainterPath::LineToElement); rects.lineTo(0, 0); QCOMPARE(rects.elementCount(), 12); QCOMPARE(rects.elementAt(10).type, QPainterPath::MoveToElement); QCOMPARE(rects.elementAt(11).type, QPainterPath::LineToElement); } { QPainterPath ellipses; ellipses.addEllipse(100, 100, 100, 100); QCOMPARE(ellipses.elementCount(), 13); QCOMPARE(ellipses.elementAt(0).type, QPainterPath::MoveToElement); QCOMPARE(ellipses.elementAt(10).type, QPainterPath::CurveToElement); ellipses.addEllipse(300, 100, 100,100); QCOMPARE(ellipses.elementCount(), 26); QCOMPARE(ellipses.elementAt(13).type, QPainterPath::MoveToElement); QCOMPARE(ellipses.elementAt(23).type, QPainterPath::CurveToElement); ellipses.lineTo(0, 0); QCOMPARE(ellipses.elementCount(), 28); QCOMPARE(ellipses.elementAt(26).type, QPainterPath::MoveToElement); QCOMPARE(ellipses.elementAt(27).type, QPainterPath::LineToElement); } { QPainterPath path; path.moveTo(10, 10); path.lineTo(40, 10); path.lineTo(25, 20); path.lineTo(10 + 1e-13, 10 + 1e-13); QCOMPARE(path.elementCount(), 4); path.closeSubpath(); QCOMPARE(path.elementCount(), 4); } }
bool gfx_font_adapter::prepare_glyph(unsigned int code) { if (m_impl->font) { m_impl->cur_glyph_index = FT_Get_Char_Index(m_impl->font, code); int error = FT_Load_Glyph(m_impl->font, m_impl->cur_glyph_index, m_impl->hinting ? FT_LOAD_DEFAULT : FT_LOAD_NO_HINTING); bool is_sys_bitmap = false; if (m_impl->font->glyph->format == FT_GLYPH_FORMAT_BITMAP) is_sys_bitmap = true; if (error == 0) { if (m_impl->antialias && !is_sys_bitmap) { if (m_impl->weight == 500) { int strength = 1 << 5; FT_Outline_Embolden(&(m_impl->font->glyph->outline), strength); } else if (m_impl->weight == 700) { int strength = 1 << 6; FT_Outline_Embolden(&(m_impl->font->glyph->outline), strength); } else if (m_impl->weight == 900) { int strength = 1 << 7; FT_Outline_Embolden(&(m_impl->font->glyph->outline), strength); } // outline text m_impl->cur_data_type = glyph_type_outline; m_impl->cur_font_path.remove_all(); if (decompose_ft_outline(m_impl->font->glyph->outline, m_impl->flip_y, m_impl->matrix, m_impl->cur_font_path)) { m_impl->cur_bound_rect = get_bounding_rect(m_impl->cur_font_path); m_impl->cur_data_size = m_impl->cur_font_path.total_byte_size()+sizeof(unsigned int);//count data m_impl->cur_advance_x = FLT_TO_SCALAR(int26p6_to_flt(m_impl->font->glyph->advance.x)); m_impl->cur_advance_y = FLT_TO_SCALAR(int26p6_to_flt(m_impl->font->glyph->advance.y)); m_impl->matrix.transform(&m_impl->cur_advance_x, &m_impl->cur_advance_y); return true; } } else { m_impl->cur_data_type = glyph_type_mono; if (is_sys_bitmap || !FT_IS_SCALABLE(m_impl->font) || m_impl->matrix.is_identity()) { gfx_scanline_bin sl; error = FT_Render_Glyph(m_impl->font->glyph, FT_RENDER_MODE_MONO); if (error == 0) { decompose_ft_bitmap_mono(m_impl->font->glyph->bitmap, m_impl->font->glyph->bitmap_left, m_impl->flip_y ? -m_impl->font->glyph->bitmap_top : m_impl->font->glyph->bitmap_top, m_impl->flip_y, sl, m_impl->cur_font_scanlines_bin); m_impl->cur_bound_rect = rect(m_impl->cur_font_scanlines_bin.min_x(), m_impl->cur_font_scanlines_bin.min_y(), m_impl->cur_font_scanlines_bin.max_x() + 1, m_impl->cur_font_scanlines_bin.max_y() + 1); m_impl->cur_data_size = m_impl->cur_font_scanlines_bin.byte_size(); m_impl->cur_advance_x = FLT_TO_SCALAR(int26p6_to_flt(m_impl->font->glyph->advance.x)); m_impl->cur_advance_y = FLT_TO_SCALAR(int26p6_to_flt(m_impl->font->glyph->advance.y)); return true; } } else { if (m_impl->weight == 500) { int strength = 1 << 5; FT_Outline_Embolden(&(m_impl->font->glyph->outline), strength); } else if (m_impl->weight == 700) { int strength = 1 << 6; FT_Outline_Embolden(&(m_impl->font->glyph->outline), strength); } else if (m_impl->weight == 900) { int strength = 1 << 7; FT_Outline_Embolden(&(m_impl->font->glyph->outline), strength); } m_impl->cur_font_path.remove_all(); if (decompose_ft_outline(m_impl->font->glyph->outline, m_impl->flip_y, m_impl->matrix, m_impl->cur_font_path)) { gfx_rasterizer_scanline_aa<> rasterizer; picasso::conv_curve curves(m_impl->cur_font_path); curves.approximation_scale(4.0); rasterizer.add_path(curves); gfx_scanline_bin sl; m_impl->cur_font_scanlines_bin.prepare(); // Remove all gfx_render_scanlines(rasterizer, sl, m_impl->cur_font_scanlines_bin); m_impl->cur_bound_rect = rect(m_impl->cur_font_scanlines_bin.min_x(), m_impl->cur_font_scanlines_bin.min_y(), m_impl->cur_font_scanlines_bin.max_x() + 1, m_impl->cur_font_scanlines_bin.max_y() + 1); m_impl->cur_data_size = m_impl->cur_font_scanlines_bin.byte_size(); m_impl->cur_advance_x = FLT_TO_SCALAR(int26p6_to_flt(m_impl->font->glyph->advance.x)); m_impl->cur_advance_y = FLT_TO_SCALAR(int26p6_to_flt(m_impl->font->glyph->advance.y)); m_impl->matrix.transform(&m_impl->cur_advance_x, &m_impl->cur_advance_y); return true; } } } } } return false; }
bool CurvesWidget::isSixteenBits() { return curves()->isSixteenBits(); }
void animated_param_t::set_min( float lo) { adobe::for_each( curves(), boost::bind( &anim::curve_t::set_min, _1, lo)); }
void animated_param_t::set_max( float hi) { adobe::for_each( curves(), boost::bind( &anim::curve_t::set_max, _1, hi)); }
void animated_param_t::set_range( float lo, float hi) { adobe::for_each( curves(), boost::bind( &anim::curve_t::set_range, _1, lo, hi)); }