void KisTransparencyMaskTest::testApply()
{
QPoint errpoint;
KisImageSP image;
KisPaintLayerSP layer;
KisPaintDeviceSP dev;
KisTransparencyMaskSP mask;
QRect applyRect(0, 0, 200, 100);
// Everything is selected
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->apply(dev, applyRect, applyRect, KisNode::N_FILTHY);
QImage qimage = dev->convertToQImage(0, 0, 0, 200, 100);
if (!TestUtil::compareQImages(errpoint,
QImage(QString(FILES_DATA_DIR) + QDir::separator() + "transparency_mask_test_2.png"),
qimage)) {
QFAIL(QString("Failed to mask out image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
// Invert the mask, so that nothing will be selected, then select a rect
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->selection()->pixelSelection()->invert();
mask->apply(dev, applyRect, applyRect, KisNode::N_FILTHY);
qimage = dev->convertToQImage(0, 0, 0, 200, 100);
if (!TestUtil::compareQImages(errpoint,
QImage(QString(FILES_DATA_DIR) + QDir::separator() + "transparency_mask_test_1.png"),
qimage)) {
QFAIL(QString("Failed to mask in image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->selection()->pixelSelection()->invert();
mask->select(QRect(50, 0, 100, 100));
mask->apply(dev, applyRect, applyRect, KisNode::N_FILTHY);
qimage = dev->convertToQImage(0, 0, 0, 200, 100);
if (!TestUtil::compareQImages(errpoint,
QImage(QString(FILES_DATA_DIR) + QDir::separator() + "transparency_mask_test_3.png"),
qimage)) {
QFAIL(QString("Failed to apply partial mask, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
Matrix::Matrix(ScriptingEnv *env, const QImage& image, const QString& label, ApplicationWindow* parent, const QString& name, Qt::WFlags f)
: MdiSubWindow(parent, label, name, f), Scripted(env)
{
m_bk_color = QColor(255, 255, 128);
m_matrix_icon = getQPixmap("matrix_xpm");
initImage(image);
}
/**
* Resizes the image so that the resulting sheet has a new size and the image
* content is zoomed to fit best into the sheet, while keeping it's aspect ration.
*
* @param w the new width to resize to
* @param h the new height to resize to
*/
void resize(int w, int h, struct IMAGE* image) {
struct IMAGE newimage;
int ww;
int hh;
float wRat;
float hRat;
if (verbose >= VERBOSE_NORMAL) {
printf("resizing %dx%d -> %dx%d\n", image->width, image->height, w, h);
}
wRat = (float)w / image->width;
hRat = (float)h / image->height;
if (wRat < hRat) { // horizontally more shrinking/less enlarging is needed: fill width fully, adjust height
ww = w;
hh = image->height * w / image->width;
} else if (hRat < wRat) {
ww = image->width * h / image->height;
hh = h;
} else { // wRat == hRat
ww = w;
hh = h;
}
stretch(ww, hh, image);
initImage(&newimage, w, h, image->bitdepth, image->color, image->background);
centerImage(image, 0, 0, w, h, &newimage);
replaceImage(image, &newimage);
}
void KisFilterMaskTest::testProjectionSelected()
{
KisImageSP image;
KisPaintLayerSP layer;
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "hakonepa.png");
QImage inverted(QString(FILES_DATA_DIR) + QDir::separator() + "inverted_hakonepa.png");
KisFilterSP f = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(f);
KisFilterConfiguration * kfc = f->defaultConfiguration(0);
Q_ASSERT(kfc);
KisFilterMaskSP mask = new KisFilterMask();
mask->setFilter(kfc);
mask->createNodeProgressProxy();
KisPaintDeviceSP projection = new KisPaintDevice(cs);
initImage(image, layer, projection, mask);
projection->convertFromQImage(qimage, 0, 0, 0);
mask->initSelection(layer);
mask->select(qimage.rect(), MAX_SELECTED);
mask->apply(projection, qimage.rect(), qimage.rect(), KisNode::N_FILTHY);
QCOMPARE(mask->exactBounds(), QRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT));
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, inverted, projection->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
projection->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save("filtermasktest2.png");
QFAIL(QString("Failed to create inverted image, first different pixel: %1,%2 ").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
}
}
void KisCoordinatesConverterTest::testConsistency()
{
KisImageSP image;
KisCoordinatesConverter converter;
initImage(&image, &converter);
converter.setImage(image);
converter.setDocumentOffset(QPoint(20,30));
converter.setCanvasWidgetSize(QSize(500,500));
QRectF testRect(100,100,100,100);
QTransform imageToWidget;
QTransform documentToWidget;
QTransform viewportToWidget;
converter.setZoom(0.5);
imageToWidget = converter.imageToWidgetTransform();
documentToWidget = converter.documentToWidgetTransform();
viewportToWidget = converter.viewportToWidgetTransform();
QRectF fromImage = converter.viewportToWidget(converter.imageToViewport(testRect));
QRectF fromDocument = converter.documentToWidget(testRect);
QRectF fromViewport = converter.viewportToWidget(testRect);
CHECK_TRANSFORM(imageToWidget, testRect, fromImage);
CHECK_TRANSFORM(documentToWidget, testRect, fromDocument);
CHECK_TRANSFORM(viewportToWidget, testRect, fromViewport);
}
void KisCoordinatesConverterTest::testRotation()
{
KisImageSP image;
KisCoordinatesConverter converter;
initImage(&image, &converter);
QSize widgetSize(1000,500);
QRectF testRect(800, 100, 300, 300);
converter.setImage(image);
converter.setDocumentOffset(QPoint(0,0));
converter.setCanvasWidgetSize(widgetSize);
converter.rotate(converter.widgetCenterPoint(), 30);
converter.setZoom(1.);
QTransform viewportToWidget = converter.viewportToWidgetTransform();
QRectF boundingRect = viewportToWidget.mapRect(testRect);
QRectF directRect = converter.viewportToWidget(testRect);
QCOMPARE(boundingRect, directRect);
QRectF referenceRect(QPointF(742.82,53.5898), QSizeF(409.808,409.808));
#define FUZZY(a,b) ((a)-(b) < 0.01)
QVERIFY(FUZZY(boundingRect.top(), referenceRect.top()));
QVERIFY(FUZZY(boundingRect.left(), referenceRect.left()));
QVERIFY(FUZZY(boundingRect.width(), referenceRect.width()));
QVERIFY(FUZZY(boundingRect.height(), referenceRect.height()));
}
CrwImage::CrwImage(BasicIo::AutoPtr io, bool create)
: io_(io)
{
if (create) {
initImage(blank_, sizeof(blank_));
}
} // CrwImage::CrwImage
void KisCoordinatesConverterTest::testMirroringCanvasBiggerThanImage()
{
KisImageSP image;
KisCoordinatesConverter converter;
initImage(&image, &converter);
QSize widgetSize(2000,2000);
QSize flakeSize(1000,1000);
QRectF testRect(300, 100, 200, 200);
converter.setImage(image);
converter.setDocumentOffset(QPoint(-50,-50));
converter.setCanvasWidgetSize(widgetSize);
QTransform imageToWidget;
QTransform documentToWidget;
QTransform flakeToWidget;
QTransform viewportToWidget;
converter.mirror(converter.imageCenterInWidgetPixel(), true, false);
converter.setZoom(1.);
// image pixels == flake pixels
QRectF viewportRect = converter.imageToViewport(testRect);
QRectF widgetRect = converter.viewportToWidget(viewportRect);
QCOMPARE(widgetRect, QRectF(550,150,200,200));
QCOMPARE(viewportRect, QRectF(300,100,200,200));
}
IplImage * createImage(int w, int h,int channels)
{
IplImage * img = NULL;
img = cvCreateImage(cvSize(w,h),IPL_DEPTH_8U,channels);
initImage(img,0);
return img;
}
int main(int argc, char *argv[])
{
if(argc!=3)
{
//fprintf(stderr,"Usage: server [portnum] [file-system-image]\n");
exit(0);
}
int portNum=atoi(argv[1]);
sprintf(imgName,argv[2]);
//Open the port
sd=UDP_Open(portNum);
assert(sd != -1);
initImage(imgName);
char buffer[sizeof(msg_t)];
//Server listening in loop
while(1)
{
//read incoming message from port
int rc=UDP_Read(sd, &addr, buffer, sizeof(msg_t));
if(rc>0)
{
handleRequest(buffer);
rc = UDP_Write(sd, &addr, buffer, sizeof(msg_t));//Send back the response to the client
}
}
return 0;
}
JpegBase::JpegBase(int type, BasicIo::AutoPtr io, bool create,
const byte initData[], long dataSize)
: Image(type, mdExif | mdIptc | mdComment, io)
{
if (create) {
initImage(initData, dataSize);
}
}
extern struct image* mockupMatrix(){
int i;
for(i = 0; i < 100; i++){
mat[i] = i;
}
struct image* img = initImage(mat, 10, 10);
return img;
}
UIWidget::UIWidget()
{
m_lastFocusReason = Fw::ActiveFocusReason;
m_states = Fw::DefaultState;
initBaseStyle();
initText();
initImage();
}
QImage utils::StrokeTester::doStroke(bool cancelled,
bool indirectPainting,
bool externalLayer,
bool testUpdates,
bool needQImage)
{
KisImageSP image = utils::createImage(0, m_imageSize);
KoCanvasResourceManager *manager = utils::createResourceManager(image, 0, m_presetFilename);
KisNodeSP currentNode;
for (int i = 0; i < m_numIterations; i++) {
modifyResourceManager(manager, image, i);
KisPainter *painter = new KisPainter();
KisResourcesSnapshotSP resources =
new KisResourcesSnapshot(image,
image->rootLayer()->firstChild(),
image->postExecutionUndoAdapter(),
manager);
if(externalLayer) {
KisNodeSP externalNode = new KisPaintLayer(0, "extlyr", OPACITY_OPAQUE_U8, image->colorSpace());
resources->setCurrentNode(externalNode);
Q_ASSERT(resources->currentNode() == externalNode);
}
initImage(image, resources->currentNode(), i);
KisStrokeStrategy *stroke = createStroke(indirectPainting, resources, painter, image);
m_strokeId = image->startStroke(stroke);
addPaintingJobs(image, resources, painter, i);
if(!cancelled) {
image->endStroke(m_strokeId);
}
else {
image->cancelStroke(m_strokeId);
}
image->waitForDone();
currentNode = resources->currentNode();
}
QImage resultImage;
if(needQImage) {
KisPaintDeviceSP device = testUpdates ?
image->projection() :
currentNode->paintDevice();
resultImage = device->convertToQImage(0, 0, 0, image->width(), image->height());
}
image = 0;
delete manager;
return resultImage;
}
metaImage * sag2coron (metaImage * imageS) {
double conf[12];
double dim[3], dimNew[3];
int dimInt[3];
metaImage imageTemp;
int i,j,k;
dim[0] = imageS->dimx;
dim[1] = imageS->dimy;
dim[2] = imageS->slices;
double matrixOut[9];
for(i = 0; i < 12; i++) {
if (i<9) matrixOut[i] = 0;
conf[i] = 0;
}
//Rotation around X of -90 degrees (positive is counterclockwise)
conf[5] = -M_PI*0.5;
//Zooming should be 1
conf[6] = conf[8] = 1;
conf[7] = 1;
forwardMatrix(matrixOut, conf);
transformLight(dim, matrixOut, dimNew, conf);
for(i =0; i<3; i++) {
dimInt[i] = rint(abs(dimNew[i]));
}
printf("%d %d %d\n",dimInt[2], dimInt[0], dimInt[1]);
// printf("%f %f %f\n",imageTemp->resolution[2], imageTemp->resolution[0], imageTemp->resolution[1]);
initImage(dimInt[2], dimInt[0], dimInt[1], &imageTemp, BACKGROUND);
setResolution(&imageTemp, imageS->resolution);
inverseMappingNewLight(imageS, &imageTemp, conf, metaWriteMatrix, trilinearInterp);
metaImage * pointer = &imageTemp;
// deInit(imageS);
return pointer;
}
UIWidget::UIWidget()
{
m_lastFocusReason = Fw::ActiveFocusReason;
m_states = Fw::DefaultState;
m_clickTimer.stop();
m_autoRepeatDelay = 500;
initBaseStyle();
initText();
initImage();
}
ImageInstance::ImageInstance(const QString &file):
rawType(false),
rawImage(0),
cachedRawCenter(0),
cachedRawWidth(-1),
dcmImage(0),
cachedCenter(0),
cachedWidth(-1),
filePath(file)
{
initImage(file);
}
void ViewerOperation::initExecution()
{
// When initializing the tree during initial load the width and height can be zero.
this->m_imageInput = getInputSocketReader(0);
this->m_alphaInput = getInputSocketReader(1);
this->m_depthInput = getInputSocketReader(2);
this->m_doDepthBuffer = (this->m_depthInput != NULL);
if (isActiveViewerOutput()) {
initImage();
}
}
void KisTransparencyMaskTest::testMoveMaskItself()
{
KisImageSP image;
KisPaintLayerSP layer;
KisPaintDeviceSP dev;
KisTransparencyMaskSP mask;
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->selection()->pixelSelection()->invert();
mask->select(QRect(50, 50, 100, 100));
KisFullRefreshWalker walker(image->bounds());
KisAsyncMerger merger;
walker.collectRects(layer, image->bounds());
merger.startMerge(walker);
// image->projection()->convertToQImage(0, 0,0,300,300).save("proj_before.png");
QRect initialRect(0,0,200,100);
QCOMPARE(layer->exactBounds(), initialRect);
QCOMPARE(image->projection()->exactBounds(), QRect(50,50,100,50));
//layer->setX(100);
//layer->setY(100);
dbgKrita << "Sel. rect before:" << mask->selection()->selectedExactRect();
mask->setX(50);
mask->setY(25);
dbgKrita << "Sel. rect after:" << mask->selection()->selectedExactRect();
QCOMPARE(mask->selection()->selectedExactRect(), QRect(100, 75, 100, 100));
QCOMPARE(layer->paintDevice()->exactBounds(), initialRect);
QCOMPARE(layer->projection()->exactBounds(), QRect(50, 50, 100, 50));
dbgKrita << "";
QRect updateRect(0,0,300,300);
walker.collectRects(mask, updateRect);
merger.startMerge(walker);
// image->projection()->convertToQImage(0, 0,0,300,300).save("proj_after.png");
QCOMPARE(layer->paintDevice()->exactBounds(), initialRect);
QCOMPARE(layer->projection()->exactBounds(), QRect(100, 75, 100, 25));
}
void TelegramImageElement::setQmlImageCreationCode(const QString &code)
{
if(p->qmlImageCreationCode == code)
return;
p->qmlImageCreationCode = code;
if(p->image)
delete p->image;
p->image = 0;
initImage();
Q_EMIT qmlImageCreationCodeChanged();
}
//! [0]
TabletCanvas::TabletCanvas()
{
resize(500, 500);
myBrush = QBrush();
myPen = QPen();
initImage();
setAutoFillBackground(true);
deviceDown = false;
myColor = Qt::red;
myTabletDevice = QTabletEvent::Stylus;
alphaChannelType = NoAlpha;
colorSaturationType = NoSaturation;
lineWidthType = LineWidthPressure;
}
void
sync_with_option(void)
{
if (PagerMax < LINES)
PagerMax = LINES;
WrapSearch = WrapDefault;
parse_proxy();
#ifdef USE_COOKIE
parse_cookie();
#endif
initMailcap();
initMimeTypes();
#ifdef USE_EXTERNAL_URI_LOADER
initURIMethods();
#endif
#ifdef USE_MIGEMO
init_migemo();
#endif
#ifdef USE_IMAGE
if (fmInitialized && displayImage)
initImage();
#else
displayImage = FALSE; /* XXX */
#endif
loadPasswd();
loadPreForm();
if (AcceptLang == NULL || *AcceptLang == '\0') {
/* TRANSLATORS:
* AcceptLang default: this is used in Accept-Language: HTTP request
* header. For example, ja.po should translate it as
* "ja;q=1.0, en;q=0.5" like that.
*/
AcceptLang = _("en;q=1.0");
}
if (AcceptEncoding == NULL || *AcceptEncoding == '\0')
AcceptEncoding = acceptableEncoding();
if (AcceptMedia == NULL || *AcceptMedia == '\0')
AcceptMedia = acceptableMimeTypes();
if (fmInitialized) {
initKeymap(FALSE);
#ifdef USE_MOUSE
initMouseAction();
#endif /* MOUSE */
#ifdef USE_MENU
initMenu();
#endif /* MENU */
}
}
void KisCoordinatesConverterTest::testImageCropping()
{
KisImageSP image;
KisCoordinatesConverter converter;
initImage(&image, &converter);
converter.setImage(image);
converter.setDocumentOffset(QPoint(0,0));
converter.setCanvasWidgetSize(QSize(500,500));
converter.setZoom(1.);
// we do NOT crop here
QCOMPARE(converter.viewportToImage(QRectF(900,900,200,200)),
QRectF(900,900,200,200));
}
bool Image::load(std::string fileName, int iAlpha /* =-1 */)
{
//Temporary storage for the image that's loaded
SDL_Surface* loadedImage = NULL;
//Load the image
// loadedImage = SDL_LoadBMP( fileName.c_str() ); //using SDL dll
loadedImage = IMG_Load(fileName.c_str()); //using SDL_Image dll (png, jpg etc)
if (NULL == loadedImage)
{
std::cerr << "Failed to load image " << fileName << ". Cannot start." << std::endl;
return false;
}
return initImage(loadedImage, iAlpha);
}
/**
* Shifts the image.
*
* @param shiftX horizontal shifting
* @param shiftY vertical shifting
*/
void shift(int shiftX, int shiftY, struct IMAGE* image) {
struct IMAGE newimage;
int x;
int y;
int pixel;
// allocate new buffer's memory
initImage(&newimage, image->width, image->height, image->bitdepth, image->color, image->background);
for (y = 0; y < image->height; y++) {
for (x = 0; x < image->width; x++) {
pixel = getPixel(x, y, image);
setPixel(pixel, x + shiftX, y + shiftY, &newimage);
}
}
replaceImage(image, &newimage);
}
void TelegramImageElement::setImage(const QString &image)
{
initImage();
if(QFileInfo(image).exists())
{
QImageReader reader(image);
p->imageSize = reader.size();
}
else
p->imageSize = QSizeF();
QVariant value = (image.isEmpty() ? QUrl() : QUrl::fromLocalFile(image));
p->image->setProperty("source", value);
p->properties["source"] = value;
Q_EMIT imageSizeChanged();
Q_EMIT currentImageChanged();
}
static void
raster_keys(unsigned char key, int x, int y)
{
(void) x;
(void) y;
switch (key) {
case 'b': /* photometric MinIsBlack */
photo = PHOTOMETRIC_MINISBLACK;
initImage();
break;
case 'l': /* lsb-to-msb FillOrder */
order = FILLORDER_LSB2MSB;
initImage();
break;
case 'm': /* msb-to-lsb FillOrder */
order = FILLORDER_MSB2LSB;
initImage();
break;
case 'w': /* photometric MinIsWhite */
photo = PHOTOMETRIC_MINISWHITE;
initImage();
break;
case 'W': /* toggle warnings */
owarning = TIFFSetWarningHandler(owarning);
initImage();
break;
case 'E': /* toggle errors */
oerror = TIFFSetErrorHandler(oerror);
initImage();
break;
case 'z': /* reset to defaults */
case 'Z':
order = order0;
photo = photo0;
if (owarning == NULL)
owarning = TIFFSetWarningHandler(NULL);
if (oerror == NULL)
oerror = TIFFSetErrorHandler(NULL);
initImage();
break;
case 'q': /* exit */
case '\033':
cleanup_and_exit();
}
glutPostRedisplay();
}
void InstagramView::urlResponse(ofHttpResponse & response){
ofUnregisterURLNotification(this);
if(response.status != 200){
return;
}
if(response.request.url == _args.imageUrl){
initImage(response.request.name);
}
if(response.request.url == _args.videoUrl){
initVideo(response.request.name);
}
if(response.request.url == _args.profilePictureUrl){
initProfileImage(response.request.name);
}
}
int main(void)
{
initImage();
initPlace();
large_font = read_font("font.txt");
initAudio();
initAudioNUM();
int IsEnding = 0;
showingPlane = START_PLANE;
while (!IsEnding)
{
clearScreen();
switch (showingPlane)
{
case 0:
start();
showingPlane = 1;
break;
case 1:
Menu();
break;
case 2:
SinglePlayer();
break;
case 3:
MuitiplePlayers();
break;
case 4:
ShowHelp();
showingPlane = 1;
break;
}
drawCmdWindow();
} /* while (IsEnding) */
return 0;
}
/**
* @brief Waveform::display
*
* Affiche le sonogramme du morceau chargé.
*/
void Waveform::display()
{
initImage();
int beg = ((SimpleMusicPlayer*) m_parent)->getWaveBegin(); //première sample affichée
int end = ((SimpleMusicPlayer*) m_parent)->getWaveEnd();
float size = end - beg; // nb de samples affichées
int s_beg = QTimeToSample(m_beginTime);
int s_bar = QTimeToSample(m_barTime);
int s_end = QTimeToSample(m_endTime);
float tmp_begin = (((float) s_beg - (float) beg) / size);
float tmp_end = (((float) s_end - (float) beg) / size);
float tmp_bar = (((float) s_bar - (float) beg) / size);
int pos_begin = tmp_begin * m_width;
int pos_bar = tmp_bar * m_width;
int pos_end = tmp_end * m_width;
//dessin du graphe
for(unsigned int i = 0; i < m_width ; i++)
{
drawColumn(i, beg, end, s_beg, s_end, pos_begin, pos_end);
}
//dessin des barres
if(s_beg > beg && s_beg < end)
{
simpleDrawColumn(pos_begin, m_height, m_delimiterPen);
}
if(s_bar > beg && s_bar < end)
{
simpleDrawColumn(pos_bar, m_height, m_delimiterPen);
}
if(s_end > beg && s_end < end)
{
simpleDrawColumn(pos_end, m_height, m_delimiterPen);
}
}
