Przeskalowywanie ukladu monitora na uklad kartezjanski

Question

Witam,

mam nietrywialny "dla mnie" problem :). Otóż mam podane wartości maksymalne rozdzielczości monitora oraz wartości maksymalne i minimalne układu współrzędnych. Zadanie polega na tym aby zmienić układ monitora na kartezjański w zależności od podanej rozdzielczości tj. wyśrodkować na ekranie, "odwrócić" oś OY monitora i przeskalować podane wartości rozdzielczości.

Pozdrawiam.

Answer 1

Co oznacza, że masz wartości maksymalne oraz minimalne układu współrzędnych? Jeśli piszesz o wyśrodkowaniu punktu (0, 0), czy to oznacza że każda półoś może być wyskalowana inaczej?

Zadanie jest w miarę proste, chociaż zależy co dokładnie masz zrobić. Narysować? Napisać funkcję, przekształcającą jedne współrzędne w inne? Czy może podać po prostu punkty charakterystyczne w jednym układzie odniesienia i odpowiadające im współrzędne w drugim?

Comments

Dokladnie i w orginale brzmi to tak:

/* Funkcja (procedura) przyjmująca współrzędne ekranu (obrazu): col i row i zwracająca przeszkalowane współrzędne w układzie "świata"
    Zadanie 1: popraw i uzupełnij kod poniższej funkcji
    Funkcja powinna spełniać poniższe wymagania:
    1. Obszar "świata" określony stałymi (minx, maxx) i (miny, maxy) powinien dokładnie wypełniać cały obszar obrazka 0..cols,0..rows
    przynajmniej wzdłuż jednej z osi
    2. Skala powinna być identyczna dla obu osi
    3. Obszar "świata" powinien być wyśrodkowany na obszarze obrazka
    4. Kierunki osi obszaru "świata" powinny być takie jak w standardowym układzie kartezjańskim
    */

 

a tresc zadania numer 2 tak

/*Funkcja (procedura) rysująca zbiór Mandelbrota
    Zadanie 2: Zaprogramować funkcję rysującą zbiór Mandelbrota

    Dla każdego piksela obrazu realizujemy algorytm:
    --------------------
    Dane: x0,y0 - przeskalowane współrzędne badanego piksela (wyrażone we współrzędnych świata)
    Dane: max_iter - maksymalna liczba iteracji
    Wynik: iter - wynikowa liczba iteracji

    iter = 0
    x=0
    y=0

    Dopóki iter < max_iter i x^2+y^2<2*2
    xnowy := x^2-y^2+x0
    ynowy := 2xy + y0
    x = xnowy
    y = ynowy
    iter = iter + 1

    ---------------------
    i zapamiętujemy liczbę iteracji za pomocą funkcji setIter
    (liczbę iteracji można traktować jak wartość koloru piksela)

    */

---

popraw i uzupełnij kod poniższej funkcji

...ech. I nadal nie wiem, co dokładnie masz zrobić. Wspomniana funkcja coś zwraca? Coś modyfikuje? Coś rysuje?

Zadanie pierwsze można przedstawić w postaci takiego polecenia: przeskaluj prostokąt o wymiarach (minx + maxx) x (miny + maxy) tak, aby zmieścił się na obszarze o wymiarach cols x rows. Umieść przeskalowany prostokąt w środku obszaru.

Do przeskalowania wystarczy proporcja, ewentualnie jakiś warunek do sprawdzenia który bok jest dłuższy.

---

Czujesz się tak samo jak ty jak dostałem do zadanie i nie wiem co mam zrobić kompletnie hahaha wiem tyle co tu jest. a mógłbyś mi jakiś pseudokod tutaj napisać na szybko i pamiętaj że minx moze byc a nawet jest ujemne :/.

---

Czujesz się tak samo jak ty jak dostałem do zadanie i nie wiem co mam zrobić kompletnie hahaha wiem tyle co tu jest.

Dostałeś polecenie, żeby poprawić kod funkcji, a kodu tej funkcji już nie dostałeś?

i pamiętaj że minx moze byc a nawet jest ujemne

Racja, trochę się pospieszyłem z wymiarami, przepraszam. Wymiar prostokąta przed skalowaniem określisz przez odjęcie współrzędnej mniejszej od większej w każdym z wymiarów.

Nie napiszę Ci pseudokodu, bo nadal nie dostałem od Ciebie informacji, co należy zrobić. Nie podałeś kodu funkcji, który masz poprawić.

---

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <cmath>
#include <math.h>

//const int cols = 1920 ;
//const int rows = 1080 ;

const int cols = 1920;
const int rows = 1080;

//Some nice part
/*
const double cx = -0.74529 ;
const double cy = 0.113075 ;
const double delta = 1.5e-4 ;

const double minx = cx - delta ;
const double maxx = cx + delta ;
const double miny = cy - delta ;
const double maxy = cy + delta ;
*/

//Default area
static double minx = -2.0;
static double maxx = 1;
static double miny = -1.0;
static double maxy = 1.0;

static unsigned char *imdata = new unsigned char[cols * rows * 3];
static int *iterdata = new int[cols * rows];
const int max_iter = 10000;

/*int round(double d)
{
	return static_cast<int>(d + 0.5);
}*/

/**
* Funkcja opracowana na podstawie:
* https://rosettacode.org/wiki/Bitmap/Write_a_PPM_file
*/
int saveImage()
{
	FILE *fp = fopen("image.ppm", "wb"); /* b - binary mode */
	fprintf(fp, "P6\n%d %d\n255\n", cols, rows);
	fwrite(imdata, 1, cols * rows * 3, fp);
	fclose(fp);
	return 1;
}


void setPixel(int col, int row, unsigned char r, unsigned char g, unsigned char b)
{
	int base = (row * cols + col) * 3;
	imdata[base] = r;
	imdata[base + 1] = g;
	imdata[base + 2] = b;
}

void setIter(int col, int row, int iter)
{
	int base = row * cols + col;
	iterdata[base] = iter;
}

int getIter(int col, int row)
{
	int base = row * cols + col;
	return iterdata[base];
}

void iter2image()
{
	//Create and zero histogram
	int *histogram = new int[max_iter + 1];
	for (int i = 0; i <= max_iter; i++)
		histogram[i] = 0;

	//Compute histogram of iteration counts
	for (int col = 0; col < cols; col++)
		for (int row = 0; row < rows; row++) {
			int iter = getIter(col, row);
			histogram[iter]++;
		}

	//Compute CDF (we have to drop first or last value)	
	histogram[0] = 0;
	for (int i = 1; i <= max_iter; i++)
		histogram[i] += histogram[i - 1];

	//Color pixels according to CDF	
	for (int col = 0; col < cols; col++)
		for (int row = 0; row < rows; row++) {
			int iter = getIter(col, row);
			double I = ((double)histogram[iter]) / histogram[max_iter];
			unsigned char r = round(255 - I * 255);

			setPixel(col, row, r, 0, 0);
		}

	//Clean-up
	delete[]histogram;
}

void image2world(int col, int row, double &x, double &y)
{
	/* Funkcja (procedura) przyjmująca współrzędne ekranu (obrazu): col i row i zwracająca przeszkalowane współrzędne w układzie "świata"
	Zadanie 1: popraw i uzupełnij kod poniższej funkcji
	Funkcja powinna spełniać poniższe wymagania:
	1. Obszar "świata" określony stałymi (minx, maxx) i (miny, maxy) powinien dokładnie wypełniać cały obszar obrazka 0..cols,0..rows
	przynajmniej wzdłuż jednej z osi
	2. Skala powinna być identyczna dla obu osi
	3. Obszar "świata" powinien być wyśrodkowany na obszarze obrazka
	4. Kierunki osi obszaru "świata" powinny być takie jak w standardowym układzie kartezjańskim
	*/
	//Tymczasowy kod

	x = col;
	y = rows - row;
}

void drawMandelbrot()
{
	/*Funkcja (procedura) rysująca zbiór Mandelbrota
	Zadanie 2: Zaprogramować funkcję rysującą zbiór Mandelbrota


	Dla każdego piksela obrazu realizujemy algorytm:
	--------------------
	Dane: x0,y0 - przeskalowane współrzędne badanego piksela (wyrażone we współrzędnych świata)
	Dane: max_iter - maksymalna liczba iteracji
	Wynik: iter - wynikowa liczba iteracji

	iter = 0
	x=0
	y=0

	Dopóki iter < max_iter i x^2+y^2<2*2
	xnowy := x^2-y^2+x0
	ynowy := 2xy + y0
	x = xnowy
	y = ynowy
	iter = iter + 1

	---------------------
	i zapamiętujemy liczbę iteracji za pomocą funkcji setIter
	(liczbę iteracji można traktować jak wartość koloru piksela)

	*/

	//Tymczasowy kod rysujący kółka
	double x, y;
	image2world(1000, 1000, x, y);

	/*int iter = 0;
	double xnowy = 0;
	double ynowy = 0;

	while (iter < max_iter && (xnowy * xnowy + ynowy * ynowy < 4))
	{
		double xnowybis = (xnowy * xnowy) - (ynowy * ynowy) + x;
		double ynowybis = 2 * xnowy * ynowy + y;
		xnowy = xnowybis;
		ynowy = ynowybis;
		iter++;
		setIter(1000, 1000, iter);
	}*/
	
	for (int col = 0; col < cols; col++)
		for (int row = 0; row < rows; row++) {
			double x0, y0;
			image2world(col, row, x0, y0);
			double xc = 500;
			double yc = 500;
			int iter = round(sqrt((x0 - xc)*(x0 - xc) + (y0 - yc)*(y0 - yc)) * 100);
			iter = iter % (max_iter + 1);
			setIter(col, row, iter);
		}
}

int main()
{
	//Just testing...coordinate conversion
	double x, y;
	image2world(20, 20, x, y);
	std::cout << x << " " << y << std::endl;
	image2world(199, 99, x, y);
	std::cout << x << " " << y << std::endl;

	//drawCircles() ;
	drawMandelbrot();
	iter2image();
	saveImage();

	delete[]imdata;
	delete[]iterdata;

	return 0;
}

 

---

No tak to w calosci wyglada :/