Kennt ihr ein Flächen Berechnungstool?
Ich habe eine benutzerdefinierte Karte von Europa und möchte die Flächen der einzelnen Länder ermitteln. Gibt es ein Programm, mit dem ich das Foto einfach hochladen kann, das dann automatisch die Flächen misst?
1 Antwort
Wenn Du das jeweilige Bild als PDF speichern kannst und Adobe Acrobat hast, dann kannst Du ein Programm nehmen, das ich gestrickt hab. Compilier es mit einem C-Compiler. Anleitung steht im Kommentarkopf.
/*-----------------------------------------------------------------------
*
* Name:
* adocurv
*
* Beschreibung:
* Erzeugung von Polygonzuegen aus PDF-Dateien mittels Adobe Acrobat 8,
* um Diagramme und Zeichnungen zu digitalisieren.
* In Adobe Acrobat 8 kann man mit
* Kommentare -> Kommentieren- und Markieren-Werkzeuge -> Polgonlinien-Werkzeug
* das manuelle Zeichnen eines Polygonzuges beginnen. Man markiert Punkte
* mit der linken Maustaste und beendet jeden Polygonzug mit der
* rechten Maustaste und "Fertig".
* Wenn man x- und y-Richtung unterschiedlich skalieren will,
* z.B. weil man Kurven in einem Diagramm digitalisiert,
* beginnt man mit einem Polygonzug, der das Koordinatensystem
* darstellt: (xmin,0) (xmax,0) (0,ymin) (0,ymax).
* Wenn man x- und y-Richtung gleich saklieren will, z.B. weil man eine
* Zeichnung digitalisiert, genuegt es stattdessen nur
* (xmin,0) und (xmax,0) einzugeben.
* Danach digitalisiert man die einzelnen Polygonzuege, wobei man jeden
* einzelnen mit rechter Maustaste und "Fertig" beendet.
* Zum Schluss speichert man sie als .fdf-Datei mittels
* Kommentare -> Kommentare in Datendatei exportieren
* und beendet Adobe Acrobat 8.
* Dieses Programm erzeugt anschliessend aus jedem Polygon eine Datei
* curv*.txt mit den Koordinaten.
* Es darf nicht "Polygon-Werkzeug" anstelle "Polygonlinien-Werkzeug"
* genommen werden.
*
* Aufruf:
* adocurv FDF-Datei xmin xmax [ymin ymax]
*
* Parameter
* FDF-Datei - die von Adobe Acrobat 8 geschriebene Datei
* xmin horizontale Weltkoordinate des ersten eingegebenen Punktes
* xmax horizontale Weltkoordinate des zweiten eingegebenen Punktes
* ymin ggf. vertikale Weltkoordinate des dritten eingegebenen Punktes
* ymax ggf. vertikale Weltkoordinate des vierten eingegebenen Punktes
*
* Eingabedateien:
* FDF-Datei
* In einem proprietaeren Format von Adobe Acrobat 8 geschriebene Datei
* mit den Polygonzuegen.
*
* Ausgabedateien:
* curv*.txt
* Im Dateinamen durchnumerierte Dateien. In jeder eine
* leerzeichengetrennte Tabelle mit zweizeiligem Header,
* einmal x[-] und einmal y[-], mit je einem Polygonzug pro Datei,
* anhand der Parameter xmin,xmax,ymin,ymax umgerechnet von
* Pixeln des PDF in Weltkoordinaten.
*
* @author: Hamberlona from gutefrage.net
* @year: 2010
*----------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#define TRUE 1
#define FALSE 0
#define PI 3.14159265
typedef struct vertex_array_ VertexArray;
struct vertex_array_
{
int n;
double *x;
double *y;
};
VertexArray *getVertexArray(unsigned char *s);
void writePolyLine(int n,VertexArray **p);
int main(int argc,char *argv[])
{
int first,i,iP,l,nPolylines,scaleBoth;
double ang,tmp,xmax,xmin,ymax,ymin;
static char line[65536];
FILE *fp;
VertexArray *axes, **polyline;
if(argc<4)
{
fprintf(stderr,"Markiere im PDF mit \n Comments -> Comment & Markup Tools -> Polygon Line Tool\n");
fprintf(stderr,"die Koordinatenachsen als 4 Punkte (xmin,0), (xmax,0), (0,ymin), (0,ymax).\n");
fprintf(stderr,"bzw. nur die x-Achse als 2 Punkte (xmin,0), (xmax,0).\n");
fprintf(stderr,"Markiere dann im PDF wieder mit \n Comments -> Comment & Markup Tools -> Polygon Line Tool\n");
fprintf(stderr,"eine oder mehrere Kurven. Kurve beenden mit re. Maustaste.\n");
fprintf(stderr,"Speichere Dein Gekritzel mit\n");
fprintf(stderr," Comments -> Export Comments to Data File\n");
fprintf(stderr,"Rufe dann auf: adocurv file xmin xmax [ymin ymax]\n");
fprintf(stderr,"und Du bekommst je ein File curv001.txt, curv002.txt, ... pro Kurve.\n");
fprintf(stderr,"Wenn Du ymin,ymax weglaesst wird das unverzerrt aus xmin,xmyax erzeugt.\n");
exit(1);
}
xmin=atof(argv[2]);
xmax=atof(argv[3]);
scaleBoth = (argc>=6);
if(scaleBoth)
{
ymin=atof(argv[4]);
ymax=atof(argv[5]);
}
if((fp=fopen(argv[1],"rb"))==(FILE *)NULL)
{
fprintf(stderr,"Cannot read file %s.\n",argv[1]);
exit(1);
}
rewind(fp);
rewind(fp);
for(i=0; i<sizeof(line)-3; ++i)
{
line[i]=fgetc(fp);
if(feof(fp))
{
// printf("EOF erreicht\n");
break;
}
}
fclose(fp);
line[i]=(char)0;
l=i;
for(i=nPolylines=0; i<l; ++i)
if(strncmp(&line[i],"/Subj(Polygon",13)==0)
++nPolylines;
--nPolylines;
if(nPolylines<=0)
{
fprintf(stderr,"No polygons found. Kisuaheli Adobe version?\n");
exit(1);
}
if((polyline=(VertexArray **)calloc(nPolylines,sizeof(VertexArray *)))==(VertexArray **)NULL)
{
fprintf(stderr,"Cannot allocate memory (1). %d polylines!\n",nPolylines);
exit(1);
}
for(i=iP=0,first=TRUE; i<l; ++i)
if(strncmp(&line[i],"/Subj(Polygon",13)==0)
{
if(first)
{
first=FALSE;
axes=getVertexArray(&line[i]);
if((axes->n < 2)||(axes->n>6))
{
fprintf(stderr,"No coordinate system marked.\n");
exit(1);
}
}
else
polyline[iP++]=getVertexArray(&line[i]);
}
if(axes->n<4)
scaleBoth=FALSE;
/* rotate image to make x axis horizontal and from left to right */
ang=atan2(axes->y[0]-axes->y[1],axes->x[1]-axes->x[0]);
if(axes->x[0]*cos(ang)-axes->y[0]*sin(ang)>axes->x[1]*cos(ang)-axes->y[1]*sin(ang))
ang+=PI;
for(i=0; i<axes->n; ++i)
{
tmp = axes->x[i]*cos(ang)-axes->y[i]*sin(ang);
axes->y[i] = axes->x[i]*sin(ang)+axes->y[i]*cos(ang);
axes->x[i] = tmp;
}
for(iP=0; iP<nPolylines; ++iP)
for(i=0; i<polyline[iP]->n; ++i)
{
tmp = polyline[iP]->x[i]*cos(ang)-polyline[iP]->y[i]*sin(ang);
polyline[iP]->y[i] = polyline[iP]->x[i]*sin(ang)+polyline[iP]->y[i]*cos(ang);
polyline[iP]->x[i] = tmp;
}
/* optional sheer the image to make y axis vertical */
if(axes->n>=4)
{
tmp = (axes->x[3]-axes->x[2])/(axes->y[2]-axes->y[3]);
for(i=0; i<axes->n; ++i)
axes->x[i] += tmp*axes->y[i];
for(iP=0; iP<nPolylines; ++iP)
for(i=0; i<polyline[iP]->n; ++i)
polyline[iP]->x[i] += tmp*polyline[iP]->y[i];
}
/* scale the image */
tmp = (xmax-xmin)/(axes->x[1]-axes->x[0]);
for(i=0; i<axes->n; ++i)
axes->x[i] *= tmp;
for(iP=0; iP<nPolylines; ++iP)
for(i=0; i<polyline[iP]->n; ++i)
polyline[iP]->x[i] *= tmp;
if(axes->n>=4) tmp = (ymax-ymin)/(axes->y[3]-axes->y[2]);
for(i=0; i<axes->n; ++i)
axes->y[i] *= tmp;
for(iP=0; iP<nPolylines; ++iP)
for(i=0; i<polyline[iP]->n; ++i)
polyline[iP]->y[i] *= tmp;
/* shift the image */
tmp=xmin-axes->x[0];
for(i=0; i<axes->n; ++i)
axes->x[i] += tmp;
for(iP=0; iP<nPolylines; ++iP)
for(i=0; i<polyline[iP]->n; ++i)
polyline[iP]->x[i] += tmp;
if(axes->n>=4)
tmp = ymin-axes->y[2];
else
tmp=-axes->y[0];
for(i=0; i<axes->n; ++i)
axes->y[i] += tmp;
for(iP=0; iP<nPolylines; ++iP)
for(i=0; i<polyline[iP]->n; ++i)
polyline[iP]->y[i] += tmp;
writePolyLine(nPolylines,polyline);
}
VertexArray *getVertexArray(unsigned char *s)
{
int i,j,k,iFrom,iTo,n,nalloc,nonBlank,prevNonBlank;
VertexArray *result;
for(iFrom=0; s[iFrom]!='['; ++iFrom)
if(!s[iFrom])
{
fprintf(stderr,"Syntax error in Adobe PDF annotations file.\n");
exit(1);
}
for(iTo=iFrom; s[iTo]!=']'; ++iTo)
if(!s[iTo])
{
fprintf(stderr,"Syntax error in Adobe PDF annotations file.\n");
exit(1);
}
for(n=0,i=iFrom+1,prevNonBlank=FALSE; i<iTo; ++i,prevNonBlank=nonBlank)
{
nonBlank = (s[i]>' ');
if(nonBlank && (!prevNonBlank))
++n;
}
if((result=(VertexArray *)calloc(1,sizeof(VertexArray)))==(VertexArray *)NULL)
{
fprintf(stderr,"Cannot allocate memory (2).\n");
exit(1);
}
result->n = n>>1;
nalloc = (result->n>=4)?result->n:4;
if(
((result->x=(double *)calloc(nalloc,sizeof(double)))==(double *)NULL)
||
((result->y=(double *)calloc(nalloc,sizeof(double)))==(double *)NULL)
) {
fprintf(stderr,"Cannot allocate memory (3).\n");
exit(1);
}
for(j=TRUE,k=0,i=iFrom+1,prevNonBlank=FALSE; i<iTo; ++i,prevNonBlank=nonBlank)
{
nonBlank = (s[i]>' ');
if(nonBlank && (!prevNonBlank))
{
if(j)
result->x[k] = atof(&s[i]);
else
result->y[k++] = atof(&s[i]);
j = !j;
}
}
return(result);
}
void writePolyLine(int n,VertexArray **p)
{
int iP,i;
double area,dx,dy,xmin,xmax;
static char fn[]={"curv000.txt"};
FILE *fp;
for(iP=0; iP<n; ++iP)
{
xmin=1.e30;
xmax=-1.e30;
sprintf(fn,"curv%03d.txt",iP+1);
if((fp=fopen(fn,"w"))==(FILE *)NULL)
{
fprintf(stderr,"Cannot write file %s.\n",fn);
exit(1);
}
fprintf(fp," x y\n");
fprintf(fp," [-] [-]\n");
for(i=0,area=0.; i<p[iP]->n; ++i)
{
fprintf(fp," %13.5e %13.5e\n",p[iP]->x[i],p[iP]->y[i]);
// fprintf(fp," %f %f\n",p[iP]->x[i],p[iP]->y[i]);
dx=p[iP]->x[(i==p[iP]->n-1) ? 0 :i+1]-p[iP]->x[i];
dy=p[iP]->y[(i==p[iP]->n-1) ? 0 :i+1]-p[iP]->y[i];
area += p[iP]->x[i]*dy-p[iP]->y[i]*dx;
if(xmin>p[iP]->x[i]) xmin=p[iP]->x[i];
if(xmax<p[iP]->x[i]) xmax=p[iP]->x[i];
}
fclose(fp);
area = area/2.;
printf("%d.) area = %f, Loa = %f\n",iP+1,area,xmax-xmin);
}
}
Ah schade. Ich habe leider kein Adobe Acrobat. Aber vielen, vielen Dank.