void PicSearch::createPreview()
{
QPixmap pm(200, 200);
QFileInfo fi = QFileInfo(currentImage);
int w = 200;
int h = 200;
bool mode = false;
QString ext = fi.suffix().toLower();
if (ext.isEmpty())
ext = getImageType(currentImage);
ScImage im;
//No doc to send data anyway, so no doc to get into scimage.
CMSettings cms(0, "", Intent_Perceptual);
cms.allowColorManagement(false);
if (im.loadPicture(currentImage, 1, cms, ScImage::Thumbnail, 72, &mode))
{
int ix,iy;
if ((im.imgInfo.exifDataValid) && (!im.imgInfo.exifInfo.thumbnail.isNull()))
{
ix = im.imgInfo.exifInfo.width;
iy = im.imgInfo.exifInfo.height;
}
else
{
ix = im.width();
iy = im.height();
}
int xres = im.imgInfo.xres;
int yres = im.imgInfo.yres;
QString tmp = "";
QString tmp2 = "";
QImage im2;
if ((ix > w-5) || (iy > h-44))
{
double sx = im.width() / static_cast<double>(w-5);
double sy = im.height() / static_cast<double>(h-44);
im2 = sy < sx ? im.scaled(qRound(im.width() / sx), qRound(im.height() / sx), Qt::IgnoreAspectRatio, Qt::SmoothTransformation)
: im.scaled(qRound(im.width() / sy), qRound(im.height() / sy), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}
else
im2 = im.qImage(); // no need to copy
QPainter p;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
p.begin(&pm);
p.fillRect(0, 0, w, h-44, b);
p.fillRect(0, h-44, w, 44, QColor(255, 255, 255));
p.drawImage((w - im2.width()) / 2, (h - 44 - im2.height()) / 2, im2);
p.drawText(2, h-29, tr("Size:")+" "+tmp.setNum(ix)+" x "+tmp2.setNum(iy));
p.drawText(2, h-17, tr("Resolution:")+" "+tmp.setNum(xres)+" x "+tmp2.setNum(yres)+" "+ tr("DPI"));
QString cSpace;
if ((extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext)) && (im.imgInfo.type != ImageType7))
cSpace = tr("Unknown");
else
cSpace=colorSpaceText(im.imgInfo.colorspace);
p.drawText(2, h-5, tr("Colorspace:")+" "+cSpace);
p.end();
repaint();
}
previewLabel->setPixmap(pm);
}
GLImageStructure readImage(const std::string& FileName, ImageType type_hint)
{
if (type_hint==itUnknown)
{
type_hint = getImageType(FileName);
}
switch (type_hint)
{
case itJPEG:
return readJPEG(FileName);
case itPNG:
return readPNG(FileName);
case itGIF:
return readGIF(FileName);
case itBitmap:
return readBMP(FileName);
case itPPM:
return readPPM(FileName);
}
//no supported image here
GLImageStructure temp_glis;
temp_glis.setWidth(0);
temp_glis.setHeight(0);
temp_glis.setFormat(0);
temp_glis.setBuffer(NULL);
return temp_glis;
}
bool ASICCD::StartStreaming()
{
ASI_IMG_TYPE type = getImageType();
if (type != ASI_IMG_Y8 && type != ASI_IMG_RGB24)
{
IUResetSwitch(&VideoFormatSP);
ISwitch *vf = IUFindSwitch(&VideoFormatSP,"ASI_IMG_Y8");
if (vf == NULL)
vf = IUFindSwitch(&VideoFormatSP,"ASI_IMG_RAW8");
if (vf)
{
vf->s = ISS_ON;
DEBUGF(INDI::Logger::DBG_DEBUG, "Switching to %s video format.", vf->label);
PrimaryCCD.setBPP(8);
UpdateCCDFrame(PrimaryCCD.getSubX(), PrimaryCCD.getSubY(), PrimaryCCD.getSubW(), PrimaryCCD.getSubH());
IDSetSwitch(&VideoFormatSP, NULL);
}
else
{
DEBUG(INDI::Logger::DBG_ERROR, "No 8 bit video format found, cannot start stream.");
return false;
}
}
ASIStartVideoCapture(m_camInfo->CameraID);
pthread_mutex_lock(&condMutex);
streamPredicate = 1;
pthread_mutex_unlock(&condMutex);
pthread_cond_signal(&cv);
return true;
}
void ofPixels_<PixelType>::setImageType(ofImageType imageType){
if(!isAllocated() || imageType==getImageType()) return;
ofPixels_<PixelType> dst;
dst.allocate(width,height,imageType);
PixelType * dstPtr = &dst[0];
PixelType * srcPtr = &pixels[0];
int diffNumChannels = 0;
if(dst.getNumChannels()<getNumChannels()){
diffNumChannels = getNumChannels()-dst.getNumChannels();
}
for(int i=0;i<width*height;i++){
const PixelType & gray = *srcPtr;
for(int j=0;j<dst.getNumChannels();j++){
if(j<getNumChannels()){
*dstPtr++ = *srcPtr++;
}else if(j<3){
*dstPtr++ = gray;
}else{
*dstPtr++ = ofColor_<PixelType>::limit();
}
}
srcPtr+=diffNumChannels;
}
swap(dst);
}
void QXmppVCard::toXmlElementFromChild(QXmlStreamWriter *writer) const
{
writer->writeStartElement("vCard");
helperToXmlAddAttribute(writer,"xmlns", ns_vcard);
if (!m_fullName.isEmpty())
helperToXmlAddTextElement(writer, "FN", m_fullName);
if(!m_nickName.isEmpty())
helperToXmlAddTextElement(writer, "NICKNAME", m_nickName);
if (!m_firstName.isEmpty() ||
!m_lastName.isEmpty() ||
!m_middleName.isEmpty())
{
writer->writeStartElement("N");
if (!m_firstName.isEmpty())
helperToXmlAddTextElement(writer, "GIVEN", m_firstName);
if (!m_lastName.isEmpty())
helperToXmlAddTextElement(writer, "FAMILY", m_lastName);
if (!m_middleName.isEmpty())
helperToXmlAddTextElement(writer, "MIDDLE", m_middleName);
writer->writeEndElement();
}
if (!m_url.isEmpty())
helperToXmlAddTextElement(writer, "URL", m_url);
if(!photo().isEmpty())
{
writer->writeStartElement("PHOTO");
helperToXmlAddTextElement(writer, "TYPE", getImageType(photo()));
helperToXmlAddTextElement(writer, "BINVAL", photo().toBase64());
writer->writeEndElement();
}
writer->writeEndElement();
}
char process_image(hdr_ent *e, FILE *finput)
{
if (is_enabled(e->image_type)) {
char * filename = calloc(strlen(odir)+BUFSIZ, 1);
FILE * foutput;
char buf[BUFSIZ];
size_t start = le32toh(e->start_s) * 512;
size_t missing = le32toh(e->sectors_t) * 512;
struct bootheader * hdr;
snprintf(filename, BUFSIZ, "%s/%s.img", odir, getImageType(e->image_type));
foutput = fopen(filename, "wb");
if (!foutput)
ERROR("ERROR: failed to open output %s\n", filename);
MESSAGE("Saving %s image in %s\n", getImageType(e->image_type), filename);
hdr = (struct bootheader *)malloc(SECTOR);
memcpy(hdr, header512, SECTOR);
hdr->sectors_t = e->sectors_t;
hdr->image_type = e->image_type;
hdr->xor56 = calc_sum(hdr);
if (fwrite(hdr, SECTOR, 1, foutput) != 1)
ERROR("ERROR: failed to write output header\n");
fflush(foutput);
if (fseek(finput, start, SEEK_SET) == -1)
ERROR("ERROR: failed to seek in input\n");
while (missing > 0) {
size_t size = fread(buf, 1, ((missing > BUFSIZ) ? BUFSIZ : missing), finput);
if (size != 0) {
fwrite(buf, 1, size, foutput);
missing -= size;
} else if (missing > 0){
ERROR("ERROR: failed to read from input\n");
}
}
free(filename);
fclose(foutput);
return 0;
} else {
MESSAGE("Skipping %s image\n", getImageType(e->image_type));
return 1;
}
}
static void testMimeType(const QString &fileName, const QString fileType)
{
// load file from resources
QFile file(":/" + fileName);
QCOMPARE(file.open(QIODevice::ReadOnly), true);
QCOMPARE(getImageType(file.readAll()), fileType);
file.close();
}
void printinfo(char * mbr, uint8_t offset)
{
printf("MBR info (offset 0x%x)\n", offset );
int i=0;
do {
hdr_ent *e = (hdr_ent*) (mbr + sizeof(mainheader) + sizeof(hdr_ent) * i++);
if (e->start_s == 0xffffffff || ((char*)e) - mbr > MBR_HDR_LEN) { break; }
printf("Image %i (%8s:%2x), start %8u, length %8u\n", i, getImageType(e->image_type), e->image_type, le32toh(e->start_s), le32toh(e->sectors_t));
} while (1);
}
CFileType
CFileUtil::
getType(CFileBase *file)
{
CFileType type = file->getType();
if (type != CFILE_TYPE_INODE_REG)
return type;
type = getImageType(file);
if (type != CFILE_TYPE_NONE)
return type;
type = getSoundType(file);
if (type != CFILE_TYPE_NONE)
return type;
type = getTextType(file);
if (type != CFILE_TYPE_NONE)
return type;
//------
std::string filename = file->getName();
type = getImageTypeFromName(filename);
if (type != CFILE_TYPE_NONE)
return type;
type = getSoundTypeFromName(filename);
if (type != CFILE_TYPE_NONE)
return type;
type = getTextTypeFromName(filename);
if (type != CFILE_TYPE_NONE)
return type;
//------
type = isText(file);
if (type != CFILE_TYPE_NONE)
return type;
return CFILE_TYPE_TEXT_BINARY;
}
void fipWinImage::setToneMappingOperator(FREE_IMAGE_TMO tmo, double first_param, double second_param) {
// avoid costly operations if possible ...
if((_tmo != tmo) || (_tmo_param_1 != first_param) || (_tmo_param_2 != second_param)) {
_tmo = tmo;
_tmo_param_1 = first_param;
_tmo_param_2 = second_param;
FREE_IMAGE_TYPE image_type = getImageType();
if((image_type == FIT_RGBF) || (image_type == FIT_RGB16)) {
_bHasChanged = TRUE;
}
}
}
std::string Image::toString() {
std::stringstream ss;
ss << "Image\nType: ";
ss << getImageType() << "\n";
ss << "Classification: (" << mClassification << ") ";
ss << getClassification() << "\n";
ss << "Width = " << mWidth << "\n";
ss << "Height = " << mHeight << "\n";
ss << "Number of channels = " << mNumChannels << std::endl;
return ss.str();
}
void QXmppVCardIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
{
writer->writeStartElement("vCard");
writer->writeAttribute("xmlns", ns_vcard);
foreach (const QXmppVCardAddress &address, d->addresses)
address.toXml(writer);
if (d->birthday.isValid())
helperToXmlAddTextElement(writer, "BDAY", d->birthday.toString("yyyy-MM-dd"));
if (!d->description.isEmpty())
helperToXmlAddTextElement(writer, "DESC", d->description);
foreach (const QXmppVCardEmail &email, d->emails)
email.toXml(writer);
if (!d->fullName.isEmpty())
helperToXmlAddTextElement(writer, "FN", d->fullName);
if(!d->nickName.isEmpty())
helperToXmlAddTextElement(writer, "NICKNAME", d->nickName);
if (!d->firstName.isEmpty() ||
!d->lastName.isEmpty() ||
!d->middleName.isEmpty())
{
writer->writeStartElement("N");
if (!d->firstName.isEmpty())
helperToXmlAddTextElement(writer, "GIVEN", d->firstName);
if (!d->lastName.isEmpty())
helperToXmlAddTextElement(writer, "FAMILY", d->lastName);
if (!d->middleName.isEmpty())
helperToXmlAddTextElement(writer, "MIDDLE", d->middleName);
writer->writeEndElement();
}
foreach (const QXmppVCardPhone &phone, d->phones)
phone.toXml(writer);
if(!photo().isEmpty())
{
writer->writeStartElement("PHOTO");
QString photoType = d->photoType;
if (photoType.isEmpty())
photoType = getImageType(d->photo);
helperToXmlAddTextElement(writer, "TYPE", photoType);
helperToXmlAddTextElement(writer, "BINVAL", d->photo.toBase64());
writer->writeEndElement();
}
if (!d->url.isEmpty())
helperToXmlAddTextElement(writer, "URL", d->url);
d->organization.toXml(writer);
writer->writeEndElement();
}
bool ofPixels_<PixelType>::resize(int dstWidth, int dstHeight, ofInterpolationMethod interpMethod){
if ((dstWidth<=0) || (dstHeight<=0) || !(isAllocated())) return false;
ofPixels_<PixelType> dstPixels;
dstPixels.allocate(dstWidth, dstHeight,getImageType());
if(!resizeTo(dstPixels,interpMethod)) return false;
delete [] pixels;
pixels = dstPixels.getPixels();
width = dstWidth;
height = dstHeight;
dstPixels.pixelsOwner = false;
return true;
}
bool ScImgDataLoader_QT::loadPicture(const QString& fn, int /*page*/, int /*res*/, bool /*thumbnail*/)
{
if (!QFile::exists(fn))
return false;
initialize();
bool loadOK = false;
QString ext2 = getImageType(fn);
if (!ext2.isEmpty())
{
ext2 = ext2.toUpper();
loadOK = m_image.load(fn, ext2.toLatin1());
}
else
loadOK = m_image.load(fn);
if (loadOK)
{
m_imageInfoRecord.type = ImageTypeOther;
m_imageInfoRecord.exifDataValid = false;
float xres = m_image.dotsPerMeterX() * 0.0254;
float yres = m_image.dotsPerMeterY() * 0.0254;
if( xres <= 1.0 || xres > 3000.0 )
xres = 72.0;
if( yres <= 1.0 || yres > 3000.0 )
yres = 72.0;
int resInf = m_imageInfoRecord.lowResType;
m_imageInfoRecord.colorspace = ColorSpaceRGB;
if (m_image.depth() == 1)
m_imageInfoRecord.colorspace = ColorSpaceMonochrome;
else if (m_image.isGrayscale() && m_image.depth() <= 16)
m_imageInfoRecord.colorspace = ColorSpaceGray;
m_image = m_image.convertToFormat(QImage::Format_ARGB32);
m_image.setDotsPerMeterX ((int) (xres / 0.0254));
m_image.setDotsPerMeterY ((int) (yres / 0.0254));
m_imageInfoRecord.xres = qRound(xres);
m_imageInfoRecord.yres = qRound(yres);
m_imageInfoRecord.lowResType = resInf;
m_imageInfoRecord.BBoxX = 0;
m_imageInfoRecord.BBoxH = m_image.height();
m_pixelFormat = Format_BGRA_8;
return true;
}
return false; //TODO: I think this should be false!
}
void fipWinImage::setToneMappingOperator(FREE_IMAGE_TMO tmo, double first_param, double second_param, double third_param, double fourth_param) {
// avoid costly operations if possible ...
if((_tmo != tmo) || (_tmo_param_1 != first_param) || (_tmo_param_2 != second_param) || (_tmo_param_3 != third_param) || (_tmo_param_4 != fourth_param)) {
_tmo = tmo;
_tmo_param_1 = first_param;
_tmo_param_2 = second_param;
_tmo_param_3 = third_param;
_tmo_param_4 = fourth_param;
FREE_IMAGE_TYPE image_type = getImageType();
switch(image_type) {
case FIT_RGBF:
case FIT_RGBAF:
case FIT_RGB16:
case FIT_RGBA16:
_bHasChanged = TRUE;
break;
default:
break;
}
}
}
void FDialogPreview::GenPreview(QString name)
{
QPixmap pm;
QString Buffer = "";
updtPix();
if (name.isEmpty())
return;
QFileInfo fi = QFileInfo(name);
if (fi.isDir())
return;
int w = pixmap()->width();
int h = pixmap()->height();
bool mode = false;
QString ext = fi.suffix().toLower();
QString formatD(FormatsManager::instance()->extensionListForFormat(FormatsManager::IMAGESIMGFRAME, 1));
QStringList formats = formatD.split("|");
formats.append("pat");
QStringList allFormatsV = LoadSavePlugin::getExtensionsForPreview(FORMATID_ODGIMPORT);
if (ext.isEmpty())
ext = getImageType(name);
if (formats.contains(ext.toUtf8()))
{
ScImage im;
//No doc to send data anyway, so no doc to get into scimage.
CMSettings cms(0, "", Intent_Perceptual);
cms.allowColorManagement(false);
if (im.loadPicture(name, 1, cms, ScImage::Thumbnail, 72, &mode))
{
int ix,iy;
if ((im.imgInfo.exifDataValid) && (!im.imgInfo.exifInfo.thumbnail.isNull()))
{
ix = im.imgInfo.exifInfo.width;
iy = im.imgInfo.exifInfo.height;
}
else
{
ix = im.width();
iy = im.height();
}
int xres = im.imgInfo.xres;
int yres = im.imgInfo.yres;
QString tmp = "";
QString tmp2 = "";
QImage im2 = im.scaled(w - 5, h - 44, Qt::KeepAspectRatio, Qt::SmoothTransformation);
QPainter p;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
// Qt4 FIXME imho should be better
pm = *pixmap();
p.begin(&pm);
p.fillRect(0, 0, w, h-44, b);
p.fillRect(0, h-44, w, 44, QColor(255, 255, 255));
p.drawImage((w - im2.width()) / 2, (h - 44 - im2.height()) / 2, im2);
p.drawText(2, h-29, tr("Size:")+" "+tmp.setNum(ix)+" x "+tmp2.setNum(iy));
p.drawText(2, h-17, tr("Resolution:")+" "+tmp.setNum(xres)+" x "+tmp2.setNum(yres)+" "+ tr("DPI"));
QString cSpace;
if ((extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext)) && (im.imgInfo.type != ImageType7))
cSpace = tr("Unknown");
else
cSpace=colorSpaceText(im.imgInfo.colorspace);
p.drawText(2, h-5, tr("Colorspace:")+" "+cSpace);
p.end();
setPixmap(pm);
repaint();
}
}
else if (allFormatsV.contains(ext.toUtf8()))
{
FileLoader *fileLoader = new FileLoader(name);
int testResult = fileLoader->TestFile();
delete fileLoader;
if ((testResult != -1) && (testResult >= FORMATID_ODGIMPORT))
{
const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
if( fmt )
{
QImage im = fmt->readThumbnail(name);
if (!im.isNull())
{
QString desc = tr("Size:")+" ";
desc += value2String(im.text("XSize").toDouble(), PrefsManager::instance()->appPrefs.docSetupPrefs.docUnitIndex, true, true);
desc += " x ";
desc += value2String(im.text("YSize").toDouble(), PrefsManager::instance()->appPrefs.docSetupPrefs.docUnitIndex, true, true);
im = im.scaled(w - 5, h - 21, Qt::KeepAspectRatio, Qt::SmoothTransformation);
QPainter p;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
pm = *pixmap();
p.begin(&pm);
p.fillRect(0, 0, w, h-21, b);
p.fillRect(0, h-21, w, 21, QColor(255, 255, 255));
p.drawImage((w - im.width()) / 2, (h - 21 - im.height()) / 2, im);
p.drawText(2, h-5, desc);
p.end();
setPixmap(pm);
repaint();
}
}
}
}
else if (ext.toUtf8() == "sml")
{
QPixmap pmi;
QByteArray cf;
if (loadRawText(name, cf))
{
QString f = QString::fromUtf8(cf.data());
StencilReader *pre = new StencilReader();
pmi = pre->createPreview(f);
QImage im = pmi.toImage();
im = im.scaled(w - 5, h - 21, Qt::KeepAspectRatio, Qt::SmoothTransformation);
QPainter p;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
pm = *pixmap();
p.begin(&pm);
p.fillRect(0, 0, w, h-21, b);
p.fillRect(0, h-21, w, 21, QColor(255, 255, 255));
p.drawImage((w - im.width()) / 2, (h - 21 - im.height()) / 2, im);
QString desc = tr("Size:")+QString(" %1 x %2").arg(im.width()).arg(im.height());
p.drawText(2, h-5, desc);
p.end();
setPixmap(pm);
repaint();
delete pre;
}
}
else if (ext.toUtf8() == "shape")
{
QByteArray cf;
if (loadRawText(name, cf))
{
QString f = QString::fromUtf8(cf.data());
StencilReader *pre = new StencilReader();
QString f2 = pre->createShape(f);
ScPreview *pre2 = new ScPreview();
QImage im = pre2->createPreview(f2);
im = im.scaled(w - 5, h - 21, Qt::KeepAspectRatio, Qt::SmoothTransformation);
QPainter p;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
pm = *pixmap();
p.begin(&pm);
p.fillRect(0, 0, w, h-21, b);
p.fillRect(0, h-21, w, 21, QColor(255, 255, 255));
p.drawImage((w - im.width()) / 2, (h - 21 - im.height()) / 2, im);
QString desc = tr("Size:")+QString(" %1 x %2").arg(im.width()).arg(im.height());
p.drawText(2, h-5, desc);
p.end();
setPixmap(pm);
repaint();
delete pre;
delete pre2;
}
}
else if (ext.toUtf8() == "sce")
{
QByteArray cf;
if (loadRawText(name, cf))
{
QString f;
if (cf.left(16) == "<SCRIBUSELEMUTF8")
f = QString::fromUtf8(cf.data());
else
f = cf.data();
ScPreview *pre = new ScPreview();
QImage im = pre->createPreview(f);
im = im.scaled(w - 5, h - 21, Qt::KeepAspectRatio, Qt::SmoothTransformation);
QPainter p;
QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
pm = *pixmap();
p.begin(&pm);
p.fillRect(0, 0, w, h-21, b);
p.fillRect(0, h-21, w, 21, QColor(255, 255, 255));
p.drawImage((w - im.width()) / 2, (h - 21 - im.height()) / 2, im);
QString desc = tr("Size:")+QString(" %1 x %2").arg(im.width()).arg(im.height());
p.drawText(2, h-5, desc);
p.end();
setPixmap(pm);
repaint();
delete pre;
}
}
else
{
ScSlaInfoReader slaInfos;
if (slaInfos.readInfos(name))
{
QString Title = tr("Title:")+" ";
QString ti2 = slaInfos.title();
if (ti2.isEmpty())
ti2= tr("No Title");
Title += ti2+"\n";
QString Author = tr("Author:")+" ";
QString au2 = slaInfos.author();
if (au2.isEmpty())
au2 = tr("Unknown");
Author += au2+"\n";
QString Format = tr("File Format:")+" ";
QString fm2 = slaInfos.format();
if (fm2.isEmpty())
fm2 = tr("Unknown");
Format += fm2;
setText( tr("Scribus Document")+"\n\n"+Title+Author+Format);
}
else if ((ext == "txt") || (ext == "html") || (ext == "xml"))
{
if (loadText(name, &Buffer))
setText(Buffer.left(200));
}
}
}
void fipWinImage::drawEx(HDC hDC, RECT& rcDest, BOOL useFileBkg, RGBQUAD *appBkColor, FIBITMAP *bg) const {
// Convert to a standard bitmap if needed
if(_bHasChanged) {
if(_bDeleteMe) {
FreeImage_Unload(_display_dib);
_display_dib = NULL;
_bDeleteMe = FALSE;
}
FREE_IMAGE_TYPE image_type = getImageType();
if(image_type == FIT_BITMAP) {
BOOL bHasBackground = FreeImage_HasBackgroundColor(_dib);
BOOL bIsTransparent = FreeImage_IsTransparent(_dib);
if(!bIsTransparent && (!bHasBackground || !useFileBkg)) {
// Copy pointer
_display_dib = _dib;
}
else {
// Create the transparent / alpha blended image
_display_dib = FreeImage_Composite(_dib, useFileBkg, appBkColor, bg);
if(_display_dib) {
// Remember to delete _display_dib
_bDeleteMe = TRUE;
} else {
// Something failed: copy pointers
_display_dib = _dib;
}
}
} else {
// Convert to a standard dib for display
if(image_type == FIT_COMPLEX) {
// Convert to type FIT_DOUBLE
FIBITMAP *dib_double = FreeImage_GetComplexChannel(_dib, FICC_MAG);
// Convert to a standard bitmap (linear scaling)
_display_dib = FreeImage_ConvertToStandardType(dib_double, TRUE);
// Free image of type FIT_DOUBLE
FreeImage_Unload(dib_double);
} else if((image_type == FIT_RGBF) || (image_type == FIT_RGB16)) {
// Apply a tone mapping algorithm and convert to 24-bit
_display_dib = FreeImage_ToneMapping(_dib, _tmo, _tmo_param_1, _tmo_param_2);
} else if(image_type == FIT_RGBA16) {
// Convert to 32-bit
FIBITMAP *dib32 = FreeImage_ConvertTo32Bits(_dib);
if(dib32) {
// Create the transparent / alpha blended image
_display_dib = FreeImage_Composite(dib32, useFileBkg, appBkColor, bg);
FreeImage_Unload(dib32);
}
} else {
// Other cases: convert to a standard bitmap (linear scaling)
_display_dib = FreeImage_ConvertToStandardType(_dib, TRUE);
}
// Remember to delete _display_dib
_bDeleteMe = TRUE;
}
_bHasChanged = FALSE;
}
// Draw the dib
SetStretchBltMode(hDC, COLORONCOLOR);
StretchDIBits(hDC, rcDest.left, rcDest.top,
rcDest.right-rcDest.left, rcDest.bottom-rcDest.top,
0, 0, FreeImage_GetWidth(_display_dib), FreeImage_GetHeight(_display_dib),
FreeImage_GetBits(_display_dib), FreeImage_GetInfo(_display_dib), DIB_RGB_COLORS, SRCCOPY);
}
vkts::IImageDataSP Example::gatherImageData() const
{
VkResult result;
auto fence = vkts::fenceCreate(device->getDevice(), 0);
if (!fence.get())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create fence.");
return vkts::IImageDataSP();
}
//
auto imageData = vkts::imageDataCreate(VKTS_IMAGE_NAME, VKTS_IMAGE_LENGTH, VKTS_IMAGE_LENGTH, 1, 1.0f, 0.0f, 0.0f, 1.0f, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM);
// Check, if we can use a linear tiled image for staging.
if (physicalDevice->isImageTilingAvailable(VK_IMAGE_TILING_LINEAR, imageData->getFormat(), imageData->getImageType(), 0, imageData->getExtent3D(), imageData->getMipLevels(), 1, VK_SAMPLE_COUNT_1_BIT, imageData->getSize()))
{
vkts::IImageSP stageImage;
vkts::IDeviceMemorySP stageDeviceMemory;
if (!createTexture(stageImage, stageDeviceMemory, VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, 0))
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create stage image and device memory.");
return vkts::IImageDataSP();
}
//
cmdBuffer->reset();
result = cmdBuffer->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not begin command buffer.");
return vkts::IImageDataSP();
}
VkImageSubresourceRange imageSubresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
// Prepare stage image for final layout etc.
stageImage->cmdPipelineBarrier(cmdBuffer->getCommandBuffer(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, imageSubresourceRange);
VkImageCopy imageCopy;
imageCopy.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
imageCopy.srcOffset = {0, 0, 0};
imageCopy.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
imageCopy.dstOffset = {0, 0, 0};
imageCopy.extent = { VKTS_IMAGE_LENGTH, VKTS_IMAGE_LENGTH, 1u };
// Copy form device to host visible image / memory. This command also sets the needed barriers.
image->copyImage(cmdBuffer->getCommandBuffer(), stageImage, imageCopy);
stageImage->cmdPipelineBarrier(cmdBuffer->getCommandBuffer(), VK_ACCESS_HOST_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, imageSubresourceRange);
result = cmdBuffer->endCommandBuffer();
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not end command buffer.");
return VK_FALSE;
}
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = nullptr;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = cmdBuffer->getCommandBuffers();
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
result = queue->submit(1, &submitInfo, fence->getFence());
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not submit queue.");
return vkts::IImageDataSP();
}
//
result = fence->waitForFence(UINT64_MAX);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not wait for fence.");
return vkts::IImageDataSP();
}
//
// Copy pixel data from device memory into image data memory.
//
VkImageSubresource imageSubresource;
imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageSubresource.mipLevel = 0;
imageSubresource.arrayLayer = 0;
VkSubresourceLayout subresourceLayout;
stageImage->getImageSubresourceLayout(subresourceLayout, imageSubresource);
//
result = stageDeviceMemory->mapMemory(0, VK_WHOLE_SIZE, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not map memory.");
return vkts::IImageDataSP();
}
imageData->upload(stageDeviceMemory->getMemory(), 0, 0, subresourceLayout);
if (!(stageDeviceMemory->getMemoryPropertyFlags() & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
result = stageDeviceMemory->invalidateMappedMemoryRanges(0, VK_WHOLE_SIZE);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not invalidate memory.");
return VK_FALSE;
}
}
stageDeviceMemory->unmapMemory();
// Stage image and device memory are automatically destroyed.
}
else
{
// As an alternative, use the buffer.
vkts::IBufferSP stageBuffer;
vkts::IDeviceMemorySP stageDeviceMemory;
VkBufferCreateInfo bufferCreateInfo{};
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferCreateInfo.size = imageData->getSize();
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
bufferCreateInfo.flags = 0;
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
bufferCreateInfo.queueFamilyIndexCount = 0;
bufferCreateInfo.pQueueFamilyIndices = nullptr;
if (!createBuffer(stageBuffer, stageDeviceMemory, bufferCreateInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create buffer.");
return vkts::IImageDataSP();
}
//
cmdBuffer->reset();
result = cmdBuffer->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not begin command buffer.");
return vkts::IImageDataSP();
}
VkBufferImageCopy bufferImageCopy;
bufferImageCopy.bufferOffset = 0;
bufferImageCopy.bufferRowLength = VKTS_IMAGE_LENGTH;
bufferImageCopy.bufferImageHeight = VKTS_IMAGE_LENGTH;
bufferImageCopy.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
bufferImageCopy.imageOffset = {0, 0, 0};
bufferImageCopy.imageExtent = {VKTS_IMAGE_LENGTH, VKTS_IMAGE_LENGTH, 1};
image->copyImageToBuffer(cmdBuffer->getCommandBuffer(), stageBuffer, bufferImageCopy);
result = cmdBuffer->endCommandBuffer();
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not end command buffer.");
return VK_FALSE;
}
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = nullptr;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = cmdBuffer->getCommandBuffers();
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
result = queue->submit(1, &submitInfo, fence->getFence());
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not submit queue.");
return vkts::IImageDataSP();
}
//
result = fence->waitForFence(UINT64_MAX);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not wait for fence.");
return vkts::IImageDataSP();
}
//
// Copy pixel data from device memory into image data memory.
//
VkSubresourceLayout subresourceLayout;
subresourceLayout.offset = 0;
subresourceLayout.size = stageBuffer->getSize();
subresourceLayout.rowPitch = VKTS_IMAGE_LENGTH * 4 * sizeof(uint8_t);
subresourceLayout.arrayPitch = VKTS_IMAGE_LENGTH * VKTS_IMAGE_LENGTH * 4 * sizeof(uint8_t);
subresourceLayout.depthPitch = VKTS_IMAGE_LENGTH * VKTS_IMAGE_LENGTH * 4 * sizeof(uint8_t);
result = stageDeviceMemory->mapMemory(0, VK_WHOLE_SIZE, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not map memory.");
return vkts::IImageDataSP();
}
imageData->upload(stageDeviceMemory->getMemory(), 0, 0, subresourceLayout);
if (!(stageDeviceMemory->getMemoryPropertyFlags() & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
result = stageDeviceMemory->invalidateMappedMemoryRanges(0, VK_WHOLE_SIZE);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not invalidate memory.");
return VK_FALSE;
}
}
stageDeviceMemory->unmapMemory();
// Stage image and device memory are automatically destroyed.
}
// Fence is automatically destroyed.
return imageData;
}
bool ASICCD::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
{
ASI_ERROR_CODE errCode = ASI_SUCCESS;
if(!strcmp(dev,getDeviceName()))
{
if (!strcmp(name, ControlSP.name))
{
IUUpdateSwitch(&ControlSP, states, names, n);
for (int i=0; i < ControlSP.nsp; i++)
{
ASI_CONTROL_TYPE swType = *((ASI_CONTROL_TYPE *) ControlS[i].aux);
ASI_BOOL swAuto = (ControlS[i].s == ISS_ON) ? ASI_TRUE : ASI_FALSE;
for (int j=0; j < ControlNP.nnp; j++)
{
ASI_CONTROL_TYPE nType = *((ASI_CONTROL_TYPE *) ControlN[j].aux0);
if (swType == nType)
{
DEBUGF(INDI::Logger::DBG_DEBUG, "ISNewSwitch->SetControlValue %d %.2f", nType, ControlN[j].value);
if ( (errCode = ASISetControlValue(m_camInfo->CameraID, nType, ControlN[j].value, swAuto )) != ASI_SUCCESS)
{
DEBUGF(INDI::Logger::DBG_ERROR, "ASISetControlValue (%s=%g) error (%d)", ControlN[j].name, ControlN[j].value, errCode);
ControlNP.s = IPS_ALERT;
ControlSP.s = IPS_ALERT;
IDSetNumber(&ControlNP, NULL);
IDSetSwitch(&ControlSP, NULL);
return false;
}
*((ASI_BOOL *) ControlN[j].aux1) = swAuto;
break;
}
}
}
ControlSP.s = IPS_OK;
IDSetSwitch(&ControlSP, NULL);
return true;
}
/* Cooler */
if (!strcmp (name, CoolerSP.name))
{
if (IUUpdateSwitch(&CoolerSP, states, names, n) < 0)
return false;
bool rc=false;
if (CoolerS[0].s == ISS_ON)
activateCooler(true);
else
activateCooler(false);
return true;
}
if (!strcmp(name, VideoFormatSP.name))
{
#if !defined(OSX_EMBEDED_MODE) && !defined(__CYGWIN__)
if (streamer->isBusy())
{
VideoFormatSP.s = IPS_ALERT;
DEBUG(INDI::Logger::DBG_ERROR, "Cannot change format while streaming/recording.");
IDSetSwitch(&VideoFormatSP, NULL);
return true;
}
#endif
IUUpdateSwitch(&VideoFormatSP, states, names, n);
ASI_IMG_TYPE type = getImageType();
switch (type)
{
case ASI_IMG_RAW16:
PrimaryCCD.setBPP(16);
break;
default:
PrimaryCCD.setBPP(8);
break;
}
UpdateCCDFrame(PrimaryCCD.getSubX(), PrimaryCCD.getSubY(), PrimaryCCD.getSubW(), PrimaryCCD.getSubH());
updateRecorderFormat();
VideoFormatSP.s = IPS_OK;
IDSetSwitch(&VideoFormatSP, NULL);
return true;
}
}
return INDI::CCD::ISNewSwitch(dev,name,states,names,n);
}
void ofPixels_<PixelType>::rotate90To(ofPixels_<PixelType> & dst, int nClockwiseRotations) const{
int channels = channelsFromPixelFormat(pixelFormat);
if (bAllocated == false || channels==0){
return;
}
if(&dst == this){
dst.rotate90(nClockwiseRotations);
return;
}
// first, figure out which type of rotation we have
int rotation = nClockwiseRotations;
while (rotation < 0){
rotation+=4;
}
rotation %= 4;
// if it's 0, just make a copy. if it's 2, do it by a mirror operation.
if (rotation == 0) {
dst = *this;
return;
// do nothing!
} else if (rotation == 2) {
mirrorTo(dst, true, true);
return;
}
// otherwise, we will need to do some new allocaiton.
dst.allocate(height,width,getImageType());
int strideSrc = width * channels;
int strideDst = dst.width * channels;
if(rotation == 1){
PixelType * srcPixels = pixels;
PixelType * startPixels = dst.getData() + strideDst;
for (int i = 0; i < height; ++i){
startPixels -= channels;
PixelType * dstPixels = startPixels;
for (int j = 0; j < width; ++j){
for (int k = 0; k < channels; ++k){
dstPixels[k] = srcPixels[k];
}
srcPixels += channels;
dstPixels += strideDst;
}
}
} else if(rotation == 3){
PixelType * dstPixels = dst.pixels;
PixelType * startPixels = pixels + strideSrc;
for (int i = 0; i < dst.height; ++i){
startPixels -= channels;
PixelType * srcPixels = startPixels;
for (int j = 0; j < dst.width; ++j){
for (int k = 0; k < channels; ++k){
dstPixels[k] = srcPixels[k];
}
srcPixels += strideSrc;
dstPixels += channels;
}
}
}
}
