KisLayerSP KisCloneLayer::reincarnateAsPaintLayer() const
{
KisPaintDeviceSP newOriginal = new KisPaintDevice(*original());
KisPaintLayerSP newLayer = new KisPaintLayer(image(), name(), opacity(), newOriginal);
newLayer->setX(newLayer->x() + x());
newLayer->setY(newLayer->y() + y());
newLayer->setCompositeOp(compositeOpId());
newLayer->mergeNodeProperties(nodeProperties());
return newLayer;
}
KisImageBuilder_Result PSDLoader::decode(const KUrl& uri)
{
// open the file
QFile f(uri.toLocalFile());
if (!f.exists()) {
return KisImageBuilder_RESULT_NOT_EXIST;
}
if (!f.open(QIODevice::ReadOnly)) {
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << "pos:" << f.pos();
PSDHeader header;
if (!header.read(&f)) {
dbgFile << "failed reading header: " << header.error;
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << header;
dbgFile << "Read header. pos:" << f.pos();
PSDColorModeBlock colorModeBlock(header.colormode);
if (!colorModeBlock.read(&f)) {
dbgFile << "failed reading colormode block: " << colorModeBlock.error;
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << "Read color mode block. pos:" << f.pos();
PSDResourceSection resourceSection;
if (!resourceSection.read(&f)) {
dbgFile << "failed reading resource section: " << resourceSection.error;
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << "Read resource section. pos:" << f.pos();
PSDLayerSection layerSection(header);
if (!layerSection.read(&f)) {
dbgFile << "failed reading layer section: " << layerSection.error;
return KisImageBuilder_RESULT_FAILURE;
}
// XXX: add all the image resource blocks as annotations to the image
dbgFile << "Read layer section. " << layerSection.nLayers << "layers. pos:" << f.pos();
// Get the right colorspace
QPair<QString, QString> colorSpaceId = psd_colormode_to_colormodelid(header.colormode,
header.channelDepth);
if (colorSpaceId.first.isNull()) return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
// Get the icc profile!
const KoColorProfile* profile = 0;
if (resourceSection.resources.contains(PSDResourceSection::ICC_PROFILE)) {
ICC_PROFILE_1039 *iccProfileData = dynamic_cast<ICC_PROFILE_1039*>(resourceSection.resources[PSDResourceSection::ICC_PROFILE]->resource);
if (iccProfileData ) {
profile = KoColorSpaceRegistry::instance()->createColorProfile(colorSpaceId.first,
colorSpaceId.second,
iccProfileData->icc);
dbgFile << "Loaded ICC profile" << profile->name();
}
}
// Create the colorspace
const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceId.first, colorSpaceId.second, profile);
if (!cs) {
return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
}
// Creating the KisImageWSP
m_image = new KisImage(m_doc->createUndoStore(), header.width, header.height, cs, "built image");
Q_CHECK_PTR(m_image);
m_image->lock();
// set the correct resolution
if (resourceSection.resources.contains(PSDResourceSection::RESN_INFO)) {
RESN_INFO_1005 *resInfo = dynamic_cast<RESN_INFO_1005*>(resourceSection.resources[PSDResourceSection::RESN_INFO]->resource);
if (resInfo) {
m_image->setResolution(POINT_TO_INCH(resInfo->hRes), POINT_TO_INCH(resInfo->vRes));
// let's skip the unit for now; we can only set that on the KoDocument, and krita doesn't use it.
}
}
// Preserve the duotone colormode block for saving back to psd
if (header.colormode == DuoTone) {
KisAnnotationSP annotation = new KisAnnotation("DuotoneColormodeBlock",
i18n("Duotone Colormode Block"),
colorModeBlock.data);
m_image->addAnnotation(annotation);
}
// read the projection into our single layer
if (layerSection.nLayers == 0) {
dbgFile << "Position" << f.pos() << "Going to read the projection into the first layer, which Photoshop calls 'Background'";
KisPaintLayerSP layer = new KisPaintLayer(m_image, i18n("Background"), OPACITY_OPAQUE_U8);
KisTransaction("", layer -> paintDevice());
PSDImageData imageData(&header);
imageData.read(&f, layer->paintDevice());
//readLayerData(&f, layer->paintDevice(), f.pos(), QRect(0, 0, header.width, header.height));
m_image->addNode(layer, m_image->rootLayer());
}
else {
// read the channels for the various layers
for(int i = 0; i < layerSection.nLayers; ++i) {
// XXX: work out the group layer structure in Photoshop, as well as the adjustment layers
PSDLayerRecord* layerRecord = layerSection.layers.at(i);
dbgFile << "Going to read channels for layer" << i << layerRecord->layerName;
KisPaintLayerSP layer = new KisPaintLayer(m_image, layerRecord->layerName, layerRecord->opacity);
layer->setCompositeOp(psd_blendmode_to_composite_op(layerRecord->blendModeKey));
if (!layerRecord->readPixelData(&f, layer->paintDevice())) {
dbgFile << "failed reading channels for layer: " << layerRecord->layerName << layerRecord->error;
return KisImageBuilder_RESULT_FAILURE;
}
m_image->addNode(layer, m_image->rootLayer());
layer->setVisible(layerRecord->visible);
}
}
m_image->unlock();
return KisImageBuilder_RESULT_OK;
}
KoFilter::ConversionStatus KisOpenEXRImport::convert(const QByteArray& from, const QByteArray& to)
{
if (from != "image/x-exr" || to != "application/x-krita") {
return KoFilter::NotImplemented;
}
dbgFile << "\n\n\nKrita importing from OpenEXR";
KisDoc2 * doc = dynamic_cast<KisDoc2*>(m_chain -> outputDocument());
if (!doc) {
return KoFilter::CreationError;
}
doc -> prepareForImport();
QString filename = m_chain -> inputFile();
if (filename.isEmpty()) {
return KoFilter::FileNotFound;
}
RgbaInputFile file(QFile::encodeName(filename));
Box2i dataWindow = file.dataWindow();
Box2i displayWindow = file.displayWindow();
dbgFile << "Data window:" << QRect(dataWindow.min.x, dataWindow.min.y, dataWindow.max.x - dataWindow.min.x + 1, dataWindow.max.y - dataWindow.min.y + 1);
dbgFile << "Display window:" << QRect(displayWindow.min.x, displayWindow.min.y, displayWindow.max.x - displayWindow.min.x + 1, displayWindow.max.y - displayWindow.min.y + 1);
int imageWidth = displayWindow.max.x - displayWindow.min.x + 1;
int imageHeight = displayWindow.max.y - displayWindow.min.y + 1;
QString imageName = "Imported from OpenEXR";
int dataWidth = dataWindow.max.x - dataWindow.min.x + 1;
int dataHeight = dataWindow.max.y - dataWindow.min.y + 1;
const KoColorSpace *cs = static_cast<const KoColorSpace *>((KoColorSpaceRegistry::instance()->colorSpace(KoID("RgbAF16", ""), "")));
if (cs == 0) {
return KoFilter::InternalError;
}
doc -> undoAdapter() -> setUndo(false);
KisImageSP image = new KisImage(doc->undoAdapter(), imageWidth, imageHeight, cs, imageName);
if (!image) {
return KoFilter::CreationError;
}
image->lock();
KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE, cs);
layer->setCompositeOp(COMPOSITE_OVER);
if (!layer) {
return KoFilter::CreationError;
}
Q3MemArray<Rgba> pixels(dataWidth);
for (int y = 0; y < dataHeight; ++y) {
file.setFrameBuffer(pixels.data() - dataWindow.min.x - (dataWindow.min.y + y) * dataWidth, 1, dataWidth);
file.readPixels(dataWindow.min.y + y);
KisHLineIterator it = layer->paintDevice()->createHLineIterator(dataWindow.min.x, dataWindow.min.y + y, dataWidth);
Rgba *rgba = pixels.data();
while (!it.isDone()) {
// XXX: For now unmultiply the alpha, though compositing will be faster if we
// keep it premultiplied.
half unmultipliedRed = rgba -> r;
half unmultipliedGreen = rgba -> g;
half unmultipliedBlue = rgba -> b;
if (rgba -> a >= HALF_EPSILON) {
unmultipliedRed /= rgba -> a;
unmultipliedGreen /= rgba -> a;
unmultipliedBlue /= rgba -> a;
}
setPixel(it.rawData(), unmultipliedRed, unmultipliedGreen, unmultipliedBlue, rgba -> a);
++it;
++rgba;
}
}
image->addNode(layer.data(), image->rootLayer().data());
layer->setDirty();
doc -> setCurrentImage(image);
doc -> undoAdapter() -> setUndo(true);
doc -> setModified(false);
image->unlock();
return KoFilter::OK;
}