void Processor::Impl::addColorSpaceConversion(const Config & config,
const ConstContextRcPtr & context,
const ConstColorSpaceRcPtr & srcColorSpace,
const ConstColorSpaceRcPtr & dstColorSpace)
{
BuildColorSpaceOps(m_cpuOps, config, context, srcColorSpace, dstColorSpace);
}
ConstProcessorRcPtr Config::getProcessor(const ConstColorSpaceRcPtr & srcColorSpace,
const ConstColorSpaceRcPtr & dstColorSpace) const
{
LocalProcessorRcPtr processor = LocalProcessor::Create();
BuildColorSpaceOps(*processor, *this, srcColorSpace, dstColorSpace);
processor->finalizeOps();
return processor;
}
void BuildLookOps(OpRcPtrVec & ops,
const Config& config,
const ConstContextRcPtr & context,
const LookTransform & lookTransform,
TransformDirection dir)
{
ConstColorSpaceRcPtr src, dst;
src = config.getColorSpace( lookTransform.getSrc() );
dst = config.getColorSpace( lookTransform.getDst() );
if(!src)
{
std::ostringstream os;
os << "BuildLookOps error.";
os << "The specified lookTransform specifies a src colorspace, '";
os << lookTransform.getSrc() << "', which is not defined.";
throw Exception(os.str().c_str());
}
if(!dst)
{
std::ostringstream os;
os << "BuildLookOps error.";
os << "The specified lookTransform specifies a dst colorspace, '";
os << lookTransform.getDst() << "', which is not defined.";
throw Exception(os.str().c_str());
}
LookParseResult looks;
looks.parse(lookTransform.getLooks());
// We must handle the inverse src/dst colorspace transformation explicitly.
if(dir == TRANSFORM_DIR_INVERSE)
{
std::swap(src, dst);
looks.reverse();
}
else if(dir == TRANSFORM_DIR_UNKNOWN)
{
std::ostringstream os;
os << "BuildLookOps error. A valid transform direction must be specified.";
throw Exception(os.str().c_str());
}
ConstColorSpaceRcPtr currentColorSpace = src;
BuildLookOps(ops,
currentColorSpace,
false,
config,
context,
looks);
BuildColorSpaceOps(ops, config, context,
currentColorSpace,
dst);
}
void BuildColorSpaceOps(OpRcPtrVec & ops,
const Config& config,
const ConstContextRcPtr & context,
const ColorSpaceTransform & colorSpaceTransform,
TransformDirection dir)
{
TransformDirection combinedDir = CombineTransformDirections(dir,
colorSpaceTransform.getDirection());
ConstColorSpaceRcPtr src, dst;
if(combinedDir == TRANSFORM_DIR_FORWARD)
{
src = config.getColorSpace( colorSpaceTransform.getSrc() );
dst = config.getColorSpace( colorSpaceTransform.getDst() );
}
else if(combinedDir == TRANSFORM_DIR_INVERSE)
{
dst = config.getColorSpace( colorSpaceTransform.getSrc() );
src = config.getColorSpace( colorSpaceTransform.getDst() );
}
BuildColorSpaceOps(ops, config, context, src, dst);
}
void BuildOps(OpRcPtrVec & ops,
const Config & config,
const ConstContextRcPtr & context,
const ConstTransformRcPtr & transform,
TransformDirection dir)
{
// A null transform is valid, and corresponds to a no-op.
if(!transform)
return;
if(ConstAllocationTransformRcPtr allocationTransform = \
DynamicPtrCast<const AllocationTransform>(transform))
{
BuildAllocationOps(ops, config, *allocationTransform, dir);
}
else if(ConstCDLTransformRcPtr cdlTransform = \
DynamicPtrCast<const CDLTransform>(transform))
{
BuildCDLOps(ops, config, *cdlTransform, dir);
}
else if(ConstColorSpaceTransformRcPtr colorSpaceTransform = \
DynamicPtrCast<const ColorSpaceTransform>(transform))
{
BuildColorSpaceOps(ops, config, context, *colorSpaceTransform, dir);
}
else if(ConstDisplayTransformRcPtr displayTransform = \
DynamicPtrCast<const DisplayTransform>(transform))
{
BuildDisplayOps(ops, config, context, *displayTransform, dir);
}
else if(ConstExponentTransformRcPtr exponentTransform = \
DynamicPtrCast<const ExponentTransform>(transform))
{
BuildExponentOps(ops, config, *exponentTransform, dir);
}
else if(ConstFileTransformRcPtr fileTransform = \
DynamicPtrCast<const FileTransform>(transform))
{
BuildFileOps(ops, config, context, *fileTransform, dir);
}
else if(ConstGroupTransformRcPtr groupTransform = \
DynamicPtrCast<const GroupTransform>(transform))
{
BuildGroupOps(ops, config, context, *groupTransform, dir);
}
else if(ConstLogTransformRcPtr logTransform = \
DynamicPtrCast<const LogTransform>(transform))
{
BuildLogOps(ops, config, *logTransform, dir);
}
else if(ConstMatrixTransformRcPtr matrixTransform = \
DynamicPtrCast<const MatrixTransform>(transform))
{
BuildMatrixOps(ops, config, *matrixTransform, dir);
}
else if(ConstTruelightTransformRcPtr truelightTransform = \
DynamicPtrCast<const TruelightTransform>(transform))
{
BuildTruelightOps(ops, config, *truelightTransform, dir);
}
else
{
std::ostringstream os;
os << "Unknown transform type for Op Creation.";
throw Exception(os.str().c_str());
}
}
