709 |
709 |
double actdist = std::numeric_limits<double>::max();
|
710 |
710 |
double x = 0;
|
711 |
711 |
double y = 0;
|
712 |
|
double *tempx, *tempy;
|
|
712 |
double tempx, tempy;
|
713 |
713 |
memcpy( &wkbType, ( mGeometry + 1 ), sizeof( int ) );
|
714 |
714 |
beforeVertex = -1;
|
715 |
715 |
afterVertex = -1;
|
... | ... | |
720 |
720 |
case QGis::WKBPoint25D:
|
721 |
721 |
case QGis::WKBPoint:
|
722 |
722 |
{
|
723 |
|
x = *(( double * )( mGeometry + 5 ) );
|
724 |
|
y = *(( double * )( mGeometry + 5 + sizeof( double ) ) );
|
|
723 |
memcpy( &x, mGeometry + 5, sizeof( x ) );
|
|
724 |
memcpy( &y, mGeometry + 5 + sizeof( double ), sizeof( y ) );
|
725 |
725 |
actdist = point.sqrDist( x, y );
|
726 |
726 |
vertexnr = 0;
|
727 |
727 |
break;
|
... | ... | |
734 |
734 |
case QGis::WKBLineString:
|
735 |
735 |
{
|
736 |
736 |
unsigned char* ptr = mGeometry + 5;
|
737 |
|
int* npoints = ( int* )ptr;
|
|
737 |
int npoints;
|
|
738 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
738 |
739 |
ptr += sizeof( int );
|
739 |
|
for ( int index = 0; index < *npoints; ++index )
|
|
740 |
for ( int index = 0; index < npoints; ++index )
|
740 |
741 |
{
|
741 |
|
tempx = ( double* )ptr;
|
|
742 |
memcpy( &tempx, ptr, sizeof( tempx ) );
|
742 |
743 |
ptr += sizeof( double );
|
743 |
|
tempy = ( double* )ptr;
|
744 |
|
if ( point.sqrDist( *tempx, *tempy ) < actdist )
|
|
744 |
memcpy( &tempy, ptr, sizeof( tempy ) );
|
|
745 |
if ( point.sqrDist( tempx, tempy ) < actdist )
|
745 |
746 |
{
|
746 |
|
x = *tempx;
|
747 |
|
y = *tempy;
|
748 |
|
actdist = point.sqrDist( *tempx, *tempy );
|
|
747 |
x = tempx;
|
|
748 |
y = tempy;
|
|
749 |
actdist = point.sqrDist( tempx, tempy );
|
749 |
750 |
vertexnr = index;
|
750 |
751 |
if ( index == 0 )//assign the rubber band indices
|
751 |
752 |
{
|
... | ... | |
755 |
756 |
{
|
756 |
757 |
beforeVertex = index - 1;
|
757 |
758 |
}
|
758 |
|
if ( index == ( *npoints - 1 ) )
|
|
759 |
if ( index == ( npoints - 1 ) )
|
759 |
760 |
{
|
760 |
761 |
afterVertex = -1;
|
761 |
762 |
}
|
... | ... | |
776 |
777 |
hasZValue = true;
|
777 |
778 |
case QGis::WKBPolygon:
|
778 |
779 |
{
|
779 |
|
int* nrings = ( int* )( mGeometry + 5 );
|
780 |
|
int* npoints;
|
|
780 |
int nrings;
|
|
781 |
memcpy( &nrings, mGeometry + 5, sizeof( nrings ) );
|
|
782 |
int npoints;
|
781 |
783 |
unsigned char* ptr = mGeometry + 9;
|
782 |
|
for ( int index = 0; index < *nrings; ++index )
|
|
784 |
for ( int index = 0; index < nrings; ++index )
|
783 |
785 |
{
|
784 |
|
npoints = ( int* )ptr;
|
|
786 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
785 |
787 |
ptr += sizeof( int );
|
786 |
|
for ( int index2 = 0; index2 < *npoints; ++index2 )
|
|
788 |
for ( int index2 = 0; index2 < npoints; ++index2 )
|
787 |
789 |
{
|
788 |
|
tempx = ( double* )ptr;
|
|
790 |
memcpy( &tempx, ptr, sizeof( tempx ) );
|
789 |
791 |
ptr += sizeof( double );
|
790 |
|
tempy = ( double* )ptr;
|
791 |
|
if ( point.sqrDist( *tempx, *tempy ) < actdist )
|
|
792 |
memcpy( &tempy, ptr, sizeof( tempy ) );
|
|
793 |
if ( point.sqrDist( tempx, tempy ) < actdist )
|
792 |
794 |
{
|
793 |
|
x = *tempx;
|
794 |
|
y = *tempy;
|
795 |
|
actdist = point.sqrDist( *tempx, *tempy );
|
|
795 |
x = tempx;
|
|
796 |
y = tempy;
|
|
797 |
actdist = point.sqrDist( tempx, tempy );
|
796 |
798 |
vertexnr = vertexcounter;
|
797 |
799 |
//assign the rubber band indices
|
798 |
800 |
if ( index2 == 0 )
|
799 |
801 |
{
|
800 |
|
beforeVertex = vertexcounter + ( *npoints - 2 );
|
|
802 |
beforeVertex = vertexcounter + ( npoints - 2 );
|
801 |
803 |
afterVertex = vertexcounter + 1;
|
802 |
804 |
}
|
803 |
|
else if ( index2 == ( *npoints - 1 ) )
|
|
805 |
else if ( index2 == ( npoints - 1 ) )
|
804 |
806 |
{
|
805 |
807 |
beforeVertex = vertexcounter - 1;
|
806 |
|
afterVertex = vertexcounter - ( *npoints - 2 );
|
|
808 |
afterVertex = vertexcounter - ( npoints - 2 );
|
807 |
809 |
}
|
808 |
810 |
else
|
809 |
811 |
{
|
... | ... | |
831 |
833 |
for ( int index = 0; index < *npoints; ++index )
|
832 |
834 |
{
|
833 |
835 |
ptr += ( 1 + sizeof( int ) ); //skip endian and point type
|
834 |
|
tempx = ( double* )ptr;
|
835 |
|
tempy = ( double* )( ptr + sizeof( double ) );
|
836 |
|
if ( point.sqrDist( *tempx, *tempy ) < actdist )
|
837 |
|
{
|
838 |
|
x = *tempx;
|
839 |
|
y = *tempy;
|
840 |
|
actdist = point.sqrDist( *tempx, *tempy );
|
|
836 |
memcpy( &tempx, ptr, sizeof( tempx ) );
|
|
837 |
memcpy( &tempy, ptr + sizeof( double ), sizeof( tempy ) );
|
|
838 |
if ( point.sqrDist( tempx, tempy ) < actdist )
|
|
839 |
{
|
|
840 |
x = tempx;
|
|
841 |
y = tempy;
|
|
842 |
actdist = point.sqrDist( tempx, tempy );
|
841 |
843 |
vertexnr = index;
|
842 |
844 |
}
|
843 |
845 |
ptr += ( 2 * sizeof( double ) );
|
... | ... | |
853 |
855 |
case QGis::WKBMultiLineString:
|
854 |
856 |
{
|
855 |
857 |
unsigned char* ptr = mGeometry + 5;
|
856 |
|
int* nlines = ( int* )ptr;
|
857 |
|
int* npoints = 0;
|
|
858 |
int nlines;
|
|
859 |
memcpy( &nlines, ptr, sizeof( nlines ) );
|
|
860 |
int npoints = 0;
|
858 |
861 |
ptr += sizeof( int );
|
859 |
|
for ( int index = 0; index < *nlines; ++index )
|
|
862 |
for ( int index = 0; index < nlines; ++index )
|
860 |
863 |
{
|
861 |
864 |
ptr += ( sizeof( int ) + 1 );
|
862 |
|
npoints = ( int* )ptr;
|
|
865 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
863 |
866 |
ptr += sizeof( int );
|
864 |
|
for ( int index2 = 0; index2 < *npoints; ++index2 )
|
|
867 |
for ( int index2 = 0; index2 < npoints; ++index2 )
|
865 |
868 |
{
|
866 |
|
tempx = ( double* )ptr;
|
|
869 |
memcpy( &tempx, ptr, sizeof( tempx ) );
|
867 |
870 |
ptr += sizeof( double );
|
868 |
|
tempy = ( double* )ptr;
|
|
871 |
memcpy( &tempy, ptr, sizeof( tempy ) );
|
869 |
872 |
ptr += sizeof( double );
|
870 |
|
if ( point.sqrDist( *tempx, *tempy ) < actdist )
|
|
873 |
if ( point.sqrDist( tempx, tempy ) < actdist )
|
871 |
874 |
{
|
872 |
|
x = *tempx;
|
873 |
|
y = *tempy;
|
874 |
|
actdist = point.sqrDist( *tempx, *tempy );
|
|
875 |
x = tempx;
|
|
876 |
y = tempy;
|
|
877 |
actdist = point.sqrDist( tempx, tempy );
|
875 |
878 |
vertexnr = vertexcounter;
|
876 |
879 |
|
877 |
880 |
if ( index2 == 0 )//assign the rubber band indices
|
... | ... | |
882 |
885 |
{
|
883 |
886 |
beforeVertex = vertexnr - 1;
|
884 |
887 |
}
|
885 |
|
if ( index2 == ( *npoints ) - 1 )
|
|
888 |
if ( index2 == ( npoints ) - 1 )
|
886 |
889 |
{
|
887 |
890 |
afterVertex = -1;
|
888 |
891 |
}
|
... | ... | |
905 |
908 |
case QGis::WKBMultiPolygon:
|
906 |
909 |
{
|
907 |
910 |
unsigned char* ptr = mGeometry + 5;
|
908 |
|
int* npolys = ( int* )ptr;
|
909 |
|
int* nrings;
|
910 |
|
int* npoints;
|
|
911 |
int npolys;
|
|
912 |
memcpy( &npolys, ptr, sizeof( npolys ) );
|
|
913 |
int nrings;
|
|
914 |
int npoints;
|
911 |
915 |
ptr += sizeof( int );
|
912 |
|
for ( int index = 0; index < *npolys; ++index )
|
|
916 |
for ( int index = 0; index < npolys; ++index )
|
913 |
917 |
{
|
914 |
918 |
ptr += ( 1 + sizeof( int ) ); //skip endian and polygon type
|
915 |
|
nrings = ( int* )ptr;
|
|
919 |
memcpy( &nrings, ptr, sizeof( nrings ) );
|
916 |
920 |
ptr += sizeof( int );
|
917 |
|
for ( int index2 = 0; index2 < *nrings; ++index2 )
|
|
921 |
for ( int index2 = 0; index2 < nrings; ++index2 )
|
918 |
922 |
{
|
919 |
|
npoints = ( int* )ptr;
|
|
923 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
920 |
924 |
ptr += sizeof( int );
|
921 |
|
for ( int index3 = 0; index3 < *npoints; ++index3 )
|
|
925 |
for ( int index3 = 0; index3 < npoints; ++index3 )
|
922 |
926 |
{
|
923 |
|
tempx = ( double* )ptr;
|
|
927 |
memcpy( &tempx, ptr, sizeof( tempx ) );
|
924 |
928 |
ptr += sizeof( double );
|
925 |
|
tempy = ( double* )ptr;
|
926 |
|
if ( point.sqrDist( *tempx, *tempy ) < actdist )
|
|
929 |
memcpy( &tempy, ptr, sizeof( tempy ) ) ;
|
|
930 |
if ( point.sqrDist( tempx, tempy ) < actdist )
|
927 |
931 |
{
|
928 |
|
x = *tempx;
|
929 |
|
y = *tempy;
|
930 |
|
actdist = point.sqrDist( *tempx, *tempy );
|
|
932 |
x = tempx;
|
|
933 |
y = tempy;
|
|
934 |
actdist = point.sqrDist( tempx, tempy );
|
931 |
935 |
vertexnr = vertexcounter;
|
932 |
936 |
|
933 |
937 |
//assign the rubber band indices
|
934 |
938 |
if ( index3 == 0 )
|
935 |
939 |
{
|
936 |
|
beforeVertex = vertexcounter + ( *npoints - 2 );
|
|
940 |
beforeVertex = vertexcounter + ( npoints - 2 );
|
937 |
941 |
afterVertex = vertexcounter + 1;
|
938 |
942 |
}
|
939 |
|
else if ( index3 == ( *npoints - 1 ) )
|
|
943 |
else if ( index3 == ( npoints - 1 ) )
|
940 |
944 |
{
|
941 |
945 |
beforeVertex = vertexcounter - 1;
|
942 |
|
afterVertex = vertexcounter - ( *npoints - 2 );
|
|
946 |
afterVertex = vertexcounter - ( npoints - 2 );
|
943 |
947 |
}
|
944 |
948 |
else
|
945 |
949 |
{
|
... | ... | |
1002 |
1006 |
case QGis::WKBLineString:
|
1003 |
1007 |
{
|
1004 |
1008 |
unsigned char* ptr = mGeometry + 5;
|
1005 |
|
int* npoints = ( int* ) ptr;
|
|
1009 |
int npoints;
|
|
1010 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
1006 |
1011 |
|
1007 |
1012 |
const int index = atVertex;
|
1008 |
1013 |
|
... | ... | |
1017 |
1022 |
beforeVertex = index - 1;
|
1018 |
1023 |
}
|
1019 |
1024 |
|
1020 |
|
if ( index == ( *npoints - 1 ) )
|
|
1025 |
if ( index == ( npoints - 1 ) )
|
1021 |
1026 |
{
|
1022 |
1027 |
afterVertex = -1;
|
1023 |
1028 |
}
|
... | ... | |
1032 |
1037 |
hasZValue = true;
|
1033 |
1038 |
case QGis::WKBPolygon:
|
1034 |
1039 |
{
|
1035 |
|
int* nrings = ( int* )( mGeometry + 5 );
|
1036 |
|
int* npoints;
|
|
1040 |
int nrings;
|
|
1041 |
memcpy( &nrings, mGeometry + 5, sizeof( nrings ) );
|
|
1042 |
int npoints;
|
1037 |
1043 |
unsigned char* ptr = mGeometry + 9;
|
1038 |
1044 |
|
1039 |
1045 |
// Walk through the POLYGON WKB
|
1040 |
1046 |
|
1041 |
|
for ( int index0 = 0; index0 < *nrings; ++index0 )
|
|
1047 |
for ( int index0 = 0; index0 < nrings; ++index0 )
|
1042 |
1048 |
{
|
1043 |
|
npoints = ( int* )ptr;
|
|
1049 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
1044 |
1050 |
ptr += sizeof( int );
|
1045 |
1051 |
|
1046 |
|
for ( int index1 = 0; index1 < *npoints; ++index1 )
|
|
1052 |
for ( int index1 = 0; index1 < npoints; ++index1 )
|
1047 |
1053 |
{
|
1048 |
1054 |
ptr += sizeof( double );
|
1049 |
1055 |
ptr += sizeof( double );
|
... | ... | |
1055 |
1061 |
{
|
1056 |
1062 |
if ( index1 == 0 )
|
1057 |
1063 |
{
|
1058 |
|
beforeVertex = vertexcounter + ( *npoints - 2 );
|
|
1064 |
beforeVertex = vertexcounter + ( npoints - 2 );
|
1059 |
1065 |
afterVertex = vertexcounter + 1;
|
1060 |
1066 |
}
|
1061 |
|
else if ( index1 == ( *npoints - 1 ) )
|
|
1067 |
else if ( index1 == ( npoints - 1 ) )
|
1062 |
1068 |
{
|
1063 |
1069 |
beforeVertex = vertexcounter - 1;
|
1064 |
|
afterVertex = vertexcounter - ( *npoints - 2 );
|
|
1070 |
afterVertex = vertexcounter - ( npoints - 2 );
|
1065 |
1071 |
}
|
1066 |
1072 |
else
|
1067 |
1073 |
{
|
... | ... | |
1087 |
1093 |
case QGis::WKBMultiLineString:
|
1088 |
1094 |
{
|
1089 |
1095 |
unsigned char* ptr = mGeometry + 5;
|
1090 |
|
int* nlines = ( int* )ptr;
|
1091 |
|
int* npoints = 0;
|
|
1096 |
int nlines;
|
|
1097 |
memcpy( &nlines, ptr, sizeof( nlines ) );
|
|
1098 |
int npoints = 0;
|
1092 |
1099 |
ptr += sizeof( int );
|
1093 |
1100 |
|
1094 |
|
for ( int index0 = 0; index0 < *nlines; ++index0 )
|
|
1101 |
for ( int index0 = 0; index0 < nlines; ++index0 )
|
1095 |
1102 |
{
|
1096 |
1103 |
ptr += ( sizeof( int ) + 1 );
|
1097 |
|
npoints = ( int* )ptr;
|
|
1104 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
1098 |
1105 |
ptr += sizeof( int );
|
1099 |
1106 |
|
1100 |
|
for ( int index1 = 0; index1 < *npoints; ++index1 )
|
|
1107 |
for ( int index1 = 0; index1 < npoints; ++index1 )
|
1101 |
1108 |
{
|
1102 |
1109 |
ptr += sizeof( double );
|
1103 |
1110 |
ptr += sizeof( double );
|
... | ... | |
1117 |
1124 |
{
|
1118 |
1125 |
beforeVertex = vertexcounter - 1;
|
1119 |
1126 |
}
|
1120 |
|
if ( index1 == ( *npoints ) - 1 )
|
|
1127 |
if ( index1 == ( npoints ) - 1 )
|
1121 |
1128 |
{
|
1122 |
1129 |
afterVertex = -1;
|
1123 |
1130 |
}
|
... | ... | |
1136 |
1143 |
case QGis::WKBMultiPolygon:
|
1137 |
1144 |
{
|
1138 |
1145 |
unsigned char* ptr = mGeometry + 5;
|
1139 |
|
int* npolys = ( int* )ptr;
|
1140 |
|
int* nrings;
|
1141 |
|
int* npoints;
|
|
1146 |
int npolys;
|
|
1147 |
memcpy( &npolys, ptr, sizeof( npolys ) );
|
|
1148 |
int nrings;
|
|
1149 |
int npoints;
|
1142 |
1150 |
ptr += sizeof( int );
|
1143 |
1151 |
|
1144 |
|
for ( int index0 = 0; index0 < *npolys; ++index0 )
|
|
1152 |
for ( int index0 = 0; index0 < npolys; ++index0 )
|
1145 |
1153 |
{
|
1146 |
1154 |
ptr += ( 1 + sizeof( int ) ); //skip endian and polygon type
|
1147 |
|
nrings = ( int* )ptr;
|
|
1155 |
memcpy( &nrings, ptr, sizeof( nrings ) );
|
1148 |
1156 |
ptr += sizeof( int );
|
1149 |
1157 |
|
1150 |
|
for ( int index1 = 0; index1 < *nrings; ++index1 )
|
|
1158 |
for ( int index1 = 0; index1 < nrings; ++index1 )
|
1151 |
1159 |
{
|
1152 |
|
npoints = ( int* )ptr;
|
|
1160 |
memcpy( &npoints, ptr, sizeof( npoints ) );
|
1153 |
1161 |
ptr += sizeof( int );
|
1154 |
1162 |
|
1155 |
|
for ( int index2 = 0; index2 < *npoints; ++index2 )
|
|
1163 |
for ( int index2 = 0; index2 < npoints; ++index2 )
|
1156 |
1164 |
{
|
1157 |
1165 |
ptr += sizeof( double );
|
1158 |
1166 |
ptr += sizeof( double );
|
... | ... | |
1167 |
1175 |
|
1168 |
1176 |
if ( index2 == 0 )
|
1169 |
1177 |
{
|
1170 |
|
beforeVertex = vertexcounter + ( *npoints - 2 );
|
|
1178 |
beforeVertex = vertexcounter + ( npoints - 2 );
|
1171 |
1179 |
afterVertex = vertexcounter + 1;
|
1172 |
1180 |
}
|
1173 |
|
else if ( index2 == ( *npoints - 1 ) )
|
|
1181 |
else if ( index2 == ( npoints - 1 ) )
|
1174 |
1182 |
{
|
1175 |
1183 |
beforeVertex = vertexcounter - 1;
|
1176 |
|
afterVertex = vertexcounter - ( *npoints - 2 );
|
|
1184 |
afterVertex = vertexcounter - ( npoints - 2 );
|
1177 |
1185 |
}
|
1178 |
1186 |
else
|
1179 |
1187 |
{
|
... | ... | |
3435 |
3443 |
double xmax = -std::numeric_limits<double>::max();
|
3436 |
3444 |
double ymax = -std::numeric_limits<double>::max();
|
3437 |
3445 |
|
3438 |
|
double *x;
|
3439 |
|
double *y;
|
3440 |
|
int *nPoints;
|
3441 |
|
int *numRings;
|
3442 |
|
int *numPolygons;
|
|
3446 |
double x;
|
|
3447 |
double y;
|
|
3448 |
int nPoints;
|
|
3449 |
int numRings;
|
|
3450 |
int numPolygons;
|
3443 |
3451 |
int numLineStrings;
|
3444 |
3452 |
int idx, jdx, kdx;
|
3445 |
3453 |
unsigned char *ptr;
|
... | ... | |
3465 |
3473 |
{
|
3466 |
3474 |
case QGis::WKBPoint25D:
|
3467 |
3475 |
case QGis::WKBPoint:
|
3468 |
|
x = ( double * )( mGeometry + 5 );
|
3469 |
|
y = ( double * )( mGeometry + 5 + sizeof( double ) );
|
3470 |
|
if ( *x < xmin )
|
|
3476 |
memcpy( &x, mGeometry + 5, sizeof( x ) );
|
|
3477 |
memcpy( &y, mGeometry + 5 + sizeof( double ), sizeof( y ) );
|
|
3478 |
if ( x < xmin )
|
3471 |
3479 |
{
|
3472 |
|
xmin = *x;
|
|
3480 |
xmin = x;
|
3473 |
3481 |
}
|
3474 |
|
if ( *x > xmax )
|
|
3482 |
if ( x > xmax )
|
3475 |
3483 |
{
|
3476 |
|
xmax = *x;
|
|
3484 |
xmax = x;
|
3477 |
3485 |
}
|
3478 |
|
if ( *y < ymin )
|
|
3486 |
if ( y < ymin )
|
3479 |
3487 |
{
|
3480 |
|
ymin = *y;
|
|
3488 |
ymin = y;
|
3481 |
3489 |
}
|
3482 |
|
if ( *y > ymax )
|
|
3490 |
if ( y > ymax )
|
3483 |
3491 |
{
|
3484 |
|
ymax = *y;
|
|
3492 |
ymax = y;
|
3485 |
3493 |
}
|
3486 |
3494 |
break;
|
3487 |
3495 |
case QGis::WKBMultiPoint25D:
|
... | ... | |
3489 |
3497 |
case QGis::WKBMultiPoint:
|
3490 |
3498 |
{
|
3491 |
3499 |
ptr = mGeometry + 1 + sizeof( int );
|
3492 |
|
nPoints = ( int * ) ptr;
|
|
3500 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
3493 |
3501 |
ptr += sizeof( int );
|
3494 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
3502 |
for ( idx = 0; idx < nPoints; idx++ )
|
3495 |
3503 |
{
|
3496 |
|
ptr += ( 1 + sizeof( int ) );
|
3497 |
|
x = ( double * ) ptr;
|
|
3504 |
ptr +=1 + sizeof( int );
|
|
3505 |
memcpy( &x, ptr, sizeof( x ) );
|
3498 |
3506 |
ptr += sizeof( double );
|
3499 |
|
y = ( double * ) ptr;
|
|
3507 |
memcpy( &y, ptr, sizeof( y ) );
|
3500 |
3508 |
ptr += sizeof( double );
|
3501 |
3509 |
if ( hasZValue )
|
3502 |
3510 |
{
|
3503 |
3511 |
ptr += sizeof( double );
|
3504 |
3512 |
}
|
3505 |
|
if ( *x < xmin )
|
|
3513 |
if ( x < xmin )
|
3506 |
3514 |
{
|
3507 |
|
xmin = *x;
|
|
3515 |
xmin = x;
|
3508 |
3516 |
}
|
3509 |
|
if ( *x > xmax )
|
|
3517 |
if ( x > xmax )
|
3510 |
3518 |
{
|
3511 |
|
xmax = *x;
|
|
3519 |
xmax = x;
|
3512 |
3520 |
}
|
3513 |
|
if ( *y < ymin )
|
|
3521 |
if ( y < ymin )
|
3514 |
3522 |
{
|
3515 |
|
ymin = *y;
|
|
3523 |
ymin = y;
|
3516 |
3524 |
}
|
3517 |
|
if ( *y > ymax )
|
|
3525 |
if ( y > ymax )
|
3518 |
3526 |
{
|
3519 |
|
ymax = *y;
|
|
3527 |
ymax = y;
|
3520 |
3528 |
}
|
3521 |
3529 |
}
|
3522 |
3530 |
break;
|
... | ... | |
3527 |
3535 |
{
|
3528 |
3536 |
// get number of points in the line
|
3529 |
3537 |
ptr = mGeometry + 5;
|
3530 |
|
nPoints = ( int * ) ptr;
|
|
3538 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
3531 |
3539 |
ptr = mGeometry + 1 + 2 * sizeof( int );
|
3532 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
3540 |
for ( idx = 0; idx < nPoints; idx++ )
|
3533 |
3541 |
{
|
3534 |
|
x = ( double * ) ptr;
|
|
3542 |
memcpy( &x, ptr, sizeof( x ) );
|
3535 |
3543 |
ptr += sizeof( double );
|
3536 |
|
y = ( double * ) ptr;
|
|
3544 |
memcpy( &y, ptr, sizeof( y ) );
|
3537 |
3545 |
ptr += sizeof( double );
|
3538 |
3546 |
if ( hasZValue )
|
3539 |
3547 |
{
|
3540 |
3548 |
ptr += sizeof( double );
|
3541 |
3549 |
}
|
3542 |
|
if ( *x < xmin )
|
|
3550 |
if ( x < xmin )
|
3543 |
3551 |
{
|
3544 |
|
xmin = *x;
|
|
3552 |
xmin = x;
|
3545 |
3553 |
}
|
3546 |
|
if ( *x > xmax )
|
|
3554 |
if ( x > xmax )
|
3547 |
3555 |
{
|
3548 |
|
xmax = *x;
|
|
3556 |
xmax = x;
|
3549 |
3557 |
}
|
3550 |
|
if ( *y < ymin )
|
|
3558 |
if ( y < ymin )
|
3551 |
3559 |
{
|
3552 |
|
ymin = *y;
|
|
3560 |
ymin = y;
|
3553 |
3561 |
}
|
3554 |
|
if ( *y > ymax )
|
|
3562 |
if ( y > ymax )
|
3555 |
3563 |
{
|
3556 |
|
ymax = *y;
|
|
3564 |
ymax = y;
|
3557 |
3565 |
}
|
3558 |
3566 |
}
|
3559 |
3567 |
break;
|
... | ... | |
3568 |
3576 |
{
|
3569 |
3577 |
// each of these is a wbklinestring so must handle as such
|
3570 |
3578 |
ptr += 5; // skip type since we know its 2
|
3571 |
|
nPoints = ( int * ) ptr;
|
|
3579 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
3572 |
3580 |
ptr += sizeof( int );
|
3573 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
3581 |
for ( idx = 0; idx < nPoints; idx++ )
|
3574 |
3582 |
{
|
3575 |
|
x = ( double * ) ptr;
|
|
3583 |
memcpy( &x, ptr, sizeof( x ) );
|
3576 |
3584 |
ptr += sizeof( double );
|
3577 |
|
y = ( double * ) ptr;
|
|
3585 |
memcpy( &y, ptr, sizeof( y ) );
|
3578 |
3586 |
ptr += sizeof( double );
|
3579 |
3587 |
if ( hasZValue )
|
3580 |
3588 |
{
|
3581 |
3589 |
ptr += sizeof( double );
|
3582 |
3590 |
}
|
3583 |
|
if ( *x < xmin )
|
|
3591 |
if ( x < xmin )
|
3584 |
3592 |
{
|
3585 |
|
xmin = *x;
|
|
3593 |
xmin = x;
|
3586 |
3594 |
}
|
3587 |
|
if ( *x > xmax )
|
|
3595 |
if ( x > xmax )
|
3588 |
3596 |
{
|
3589 |
|
xmax = *x;
|
|
3597 |
xmax = x;
|
3590 |
3598 |
}
|
3591 |
|
if ( *y < ymin )
|
|
3599 |
if ( y < ymin )
|
3592 |
3600 |
{
|
3593 |
|
ymin = *y;
|
|
3601 |
ymin = y;
|
3594 |
3602 |
}
|
3595 |
|
if ( *y > ymax )
|
|
3603 |
if ( y > ymax )
|
3596 |
3604 |
{
|
3597 |
|
ymax = *y;
|
|
3605 |
ymax = y;
|
3598 |
3606 |
}
|
3599 |
3607 |
}
|
3600 |
3608 |
}
|
... | ... | |
3605 |
3613 |
case QGis::WKBPolygon:
|
3606 |
3614 |
{
|
3607 |
3615 |
// get number of rings in the polygon
|
3608 |
|
numRings = ( int * )( mGeometry + 1 + sizeof( int ) );
|
|
3616 |
ptr = mGeometry + 1 + sizeof( int );
|
|
3617 |
memcpy( &numRings, ptr, sizeof( numRings ) );
|
3609 |
3618 |
ptr = mGeometry + 1 + 2 * sizeof( int );
|
3610 |
|
for ( idx = 0; idx < *numRings; idx++ )
|
|
3619 |
for ( idx = 0; idx < numRings; idx++ )
|
3611 |
3620 |
{
|
3612 |
3621 |
// get number of points in the ring
|
3613 |
|
nPoints = ( int * ) ptr;
|
|
3622 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
3614 |
3623 |
ptr += 4;
|
3615 |
|
for ( jdx = 0; jdx < *nPoints; jdx++ )
|
|
3624 |
for ( jdx = 0; jdx < nPoints; jdx++ )
|
3616 |
3625 |
{
|
3617 |
3626 |
// add points to a point array for drawing the polygon
|
3618 |
|
x = ( double * ) ptr;
|
|
3627 |
memcpy( &x, ptr, sizeof( x ) );
|
3619 |
3628 |
ptr += sizeof( double );
|
3620 |
|
y = ( double * ) ptr;
|
|
3629 |
memcpy( &y, ptr, sizeof( y ) );
|
3621 |
3630 |
ptr += sizeof( double );
|
3622 |
3631 |
if ( hasZValue )
|
3623 |
3632 |
{
|
3624 |
3633 |
ptr += sizeof( double );
|
3625 |
3634 |
}
|
3626 |
|
if ( *x < xmin )
|
|
3635 |
if ( x < xmin )
|
3627 |
3636 |
{
|
3628 |
|
xmin = *x;
|
|
3637 |
xmin = x;
|
3629 |
3638 |
}
|
3630 |
|
if ( *x > xmax )
|
|
3639 |
if ( x > xmax )
|
3631 |
3640 |
{
|
3632 |
|
xmax = *x;
|
|
3641 |
xmax = x;
|
3633 |
3642 |
}
|
3634 |
|
if ( *y < ymin )
|
|
3643 |
if ( y < ymin )
|
3635 |
3644 |
{
|
3636 |
|
ymin = *y;
|
|
3645 |
ymin = y;
|
3637 |
3646 |
}
|
3638 |
|
if ( *y > ymax )
|
|
3647 |
if ( y > ymax )
|
3639 |
3648 |
{
|
3640 |
|
ymax = *y;
|
|
3649 |
ymax = y;
|
3641 |
3650 |
}
|
3642 |
3651 |
}
|
3643 |
3652 |
}
|
... | ... | |
3649 |
3658 |
{
|
3650 |
3659 |
// get the number of polygons
|
3651 |
3660 |
ptr = mGeometry + 5;
|
3652 |
|
numPolygons = ( int * ) ptr;
|
|
3661 |
memcpy( &numPolygons, ptr, sizeof( numPolygons ) );
|
3653 |
3662 |
ptr += 4;
|
3654 |
3663 |
|
3655 |
|
for ( kdx = 0; kdx < *numPolygons; kdx++ )
|
|
3664 |
for ( kdx = 0; kdx < numPolygons; kdx++ )
|
3656 |
3665 |
{
|
3657 |
3666 |
//skip the endian and mGeometry type info and
|
3658 |
3667 |
// get number of rings in the polygon
|
3659 |
3668 |
ptr += 5;
|
3660 |
|
numRings = ( int * ) ptr;
|
|
3669 |
memcpy( &numRings, ptr, sizeof( numRings ) );
|
3661 |
3670 |
ptr += 4;
|
3662 |
|
for ( idx = 0; idx < *numRings; idx++ )
|
|
3671 |
for ( idx = 0; idx < numRings; idx++ )
|
3663 |
3672 |
{
|
3664 |
3673 |
// get number of points in the ring
|
3665 |
|
nPoints = ( int * ) ptr;
|
|
3674 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
3666 |
3675 |
ptr += 4;
|
3667 |
|
for ( jdx = 0; jdx < *nPoints; jdx++ )
|
|
3676 |
for ( jdx = 0; jdx < nPoints; jdx++ )
|
3668 |
3677 |
{
|
3669 |
3678 |
// add points to a point array for drawing the polygon
|
3670 |
|
x = ( double * ) ptr;
|
|
3679 |
memcpy( &x, ptr, sizeof( x ) );
|
3671 |
3680 |
ptr += sizeof( double );
|
3672 |
|
y = ( double * ) ptr;
|
|
3681 |
memcpy( &y, ptr, sizeof( y ) );
|
3673 |
3682 |
ptr += sizeof( double );
|
3674 |
3683 |
if ( hasZValue )
|
3675 |
3684 |
{
|
3676 |
3685 |
ptr += sizeof( double );
|
3677 |
3686 |
}
|
3678 |
|
if ( *x < xmin )
|
|
3687 |
if ( x < xmin )
|
3679 |
3688 |
{
|
3680 |
|
xmin = *x;
|
|
3689 |
xmin = x;
|
3681 |
3690 |
}
|
3682 |
|
if ( *x > xmax )
|
|
3691 |
if ( x > xmax )
|
3683 |
3692 |
{
|
3684 |
|
xmax = *x;
|
|
3693 |
xmax = x;
|
3685 |
3694 |
}
|
3686 |
|
if ( *y < ymin )
|
|
3695 |
if ( y < ymin )
|
3687 |
3696 |
{
|
3688 |
|
ymin = *y;
|
|
3697 |
ymin = y;
|
3689 |
3698 |
}
|
3690 |
|
if ( *y > ymax )
|
|
3699 |
if ( y > ymax )
|
3691 |
3700 |
{
|
3692 |
|
ymax = *y;
|
|
3701 |
ymax = y;
|
3693 |
3702 |
}
|
3694 |
3703 |
}
|
3695 |
3704 |
}
|
... | ... | |
3839 |
3848 |
|
3840 |
3849 |
QGis::WkbType wkbType;
|
3841 |
3850 |
bool hasZValue = false;
|
3842 |
|
double *x, *y;
|
|
3851 |
double x, y;
|
3843 |
3852 |
|
3844 |
3853 |
QString mWkt; // TODO: rename
|
3845 |
3854 |
|
... | ... | |
3853 |
3862 |
case QGis::WKBPoint:
|
3854 |
3863 |
{
|
3855 |
3864 |
mWkt += "POINT(";
|
3856 |
|
x = ( double * )( mGeometry + 5 );
|
3857 |
|
mWkt += QString::number( *x, 'f', 6 );
|
|
3865 |
memcpy( &x, mGeometry + 5, sizeof( x ) );
|
|
3866 |
mWkt += QString::number( x, 'f', 6 );
|
3858 |
3867 |
mWkt += " ";
|
3859 |
|
y = ( double * )( mGeometry + 5 + sizeof( double ) );
|
3860 |
|
mWkt += QString::number( *y, 'f', 6 );
|
|
3868 |
memcpy( &y, mGeometry + 5 + sizeof( double ), sizeof( y ) );
|
|
3869 |
mWkt += QString::number( y, 'f', 6 );
|
3861 |
3870 |
mWkt += ")";
|
3862 |
3871 |
return mWkt;
|
3863 |
3872 |
}
|
... | ... | |
3868 |
3877 |
{
|
3869 |
3878 |
QgsDebugMsg( "LINESTRING found" );
|
3870 |
3879 |
unsigned char *ptr;
|
3871 |
|
int *nPoints;
|
|
3880 |
int nPoints;
|
3872 |
3881 |
int idx;
|
3873 |
3882 |
|
3874 |
3883 |
mWkt += "LINESTRING(";
|
3875 |
3884 |
// get number of points in the line
|
3876 |
3885 |
ptr = mGeometry + 5;
|
3877 |
|
nPoints = ( int * ) ptr;
|
|
3886 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
3878 |
3887 |
ptr = mGeometry + 1 + 2 * sizeof( int );
|
3879 |
|
for ( idx = 0; idx < *nPoints; ++idx )
|
|
3888 |
for ( idx = 0; idx < nPoints; ++idx )
|
3880 |
3889 |
{
|
3881 |
3890 |
if ( idx != 0 )
|
3882 |
3891 |
{
|
3883 |
3892 |
mWkt += ", ";
|
3884 |
3893 |
}
|
3885 |
|
x = ( double * ) ptr;
|
3886 |
|
mWkt += QString::number( *x, 'f', 6 );
|
|
3894 |
memcpy( &x, ptr, sizeof( x ) );
|
|
3895 |
mWkt += QString::number( x, 'f', 6 );
|
3887 |
3896 |
mWkt += " ";
|
3888 |
3897 |
ptr += sizeof( double );
|
3889 |
|
y = ( double * ) ptr;
|
3890 |
|
mWkt += QString::number( *y, 'f', 6 );
|
|
3898 |
memcpy( &y, ptr, sizeof( y ) );
|
|
3899 |
mWkt += QString::number( y, 'f', 6 );
|
3891 |
3900 |
ptr += sizeof( double );
|
3892 |
3901 |
if ( hasZValue )
|
3893 |
3902 |
{
|
... | ... | |
3905 |
3914 |
QgsDebugMsg( "POLYGON found" );
|
3906 |
3915 |
unsigned char *ptr;
|
3907 |
3916 |
int idx, jdx;
|
3908 |
|
int *numRings, *nPoints;
|
|
3917 |
int numRings, nPoints;
|
3909 |
3918 |
|
3910 |
3919 |
mWkt += "POLYGON(";
|
3911 |
3920 |
// get number of rings in the polygon
|
3912 |
|
numRings = ( int * )( mGeometry + 1 + sizeof( int ) );
|
3913 |
|
if ( !( *numRings ) ) // sanity check for zero rings in polygon
|
|
3921 |
memcpy( &numRings, mGeometry + 1 + sizeof( int ), sizeof( numRings ) );
|
|
3922 |
if ( !( numRings ) ) // sanity check for zero rings in polygon
|
3914 |
3923 |
{
|
3915 |
3924 |
return QString();
|
3916 |
3925 |
}
|
3917 |
3926 |
int *ringStart; // index of first point for each ring
|
3918 |
3927 |
int *ringNumPoints; // number of points in each ring
|
3919 |
|
ringStart = new int[*numRings];
|
3920 |
|
ringNumPoints = new int[*numRings];
|
|
3928 |
ringStart = new int[numRings];
|
|
3929 |
ringNumPoints = new int[numRings];
|
3921 |
3930 |
ptr = mGeometry + 1 + 2 * sizeof( int ); // set pointer to the first ring
|
3922 |
|
for ( idx = 0; idx < *numRings; idx++ )
|
|
3931 |
for ( idx = 0; idx < numRings; idx++ )
|
3923 |
3932 |
{
|
3924 |
3933 |
if ( idx != 0 )
|
3925 |
3934 |
{
|
... | ... | |
3927 |
3936 |
}
|
3928 |
3937 |
mWkt += "(";
|
3929 |
3938 |
// get number of points in the ring
|
3930 |
|
nPoints = ( int * ) ptr;
|
3931 |
|
ringNumPoints[idx] = *nPoints;
|
|
3939 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
|
3940 |
ringNumPoints[idx] = nPoints;
|
3932 |
3941 |
ptr += 4;
|
3933 |
3942 |
|
3934 |
|
for ( jdx = 0; jdx < *nPoints; jdx++ )
|
|
3943 |
for ( jdx = 0; jdx < nPoints; jdx++ )
|
3935 |
3944 |
{
|
3936 |
3945 |
if ( jdx != 0 )
|
3937 |
3946 |
{
|
3938 |
3947 |
mWkt += ",";
|
3939 |
3948 |
}
|
3940 |
|
x = ( double * ) ptr;
|
3941 |
|
mWkt += QString::number( *x, 'f', 6 );
|
|
3949 |
memcpy( &x, ptr, sizeof( x ) );
|
|
3950 |
mWkt += QString::number( x, 'f', 6 );
|
3942 |
3951 |
mWkt += " ";
|
3943 |
3952 |
ptr += sizeof( double );
|
3944 |
|
y = ( double * ) ptr;
|
3945 |
|
mWkt += QString::number( *y, 'f', 6 );
|
|
3953 |
memcpy( &y, ptr, sizeof( y ) );
|
|
3954 |
mWkt += QString::number( y, 'f', 6 );
|
3946 |
3955 |
ptr += sizeof( double );
|
3947 |
3956 |
if ( hasZValue )
|
3948 |
3957 |
{
|
... | ... | |
3963 |
3972 |
{
|
3964 |
3973 |
unsigned char *ptr;
|
3965 |
3974 |
int idx;
|
3966 |
|
int *nPoints;
|
|
3975 |
int nPoints;
|
3967 |
3976 |
|
3968 |
3977 |
mWkt += "MULTIPOINT(";
|
3969 |
|
nPoints = ( int* )( mGeometry + 5 );
|
|
3978 |
memcpy( &nPoints, mGeometry + 5, sizeof( nPoints ) );
|
3970 |
3979 |
ptr = mGeometry + 5 + sizeof( int );
|
3971 |
|
for ( idx = 0; idx < *nPoints; ++idx )
|
|
3980 |
for ( idx = 0; idx < nPoints; ++idx )
|
3972 |
3981 |
{
|
3973 |
3982 |
ptr += ( 1 + sizeof( int ) );
|
3974 |
3983 |
if ( idx != 0 )
|
3975 |
3984 |
{
|
3976 |
3985 |
mWkt += ", ";
|
3977 |
3986 |
}
|
3978 |
|
x = ( double * )( ptr );
|
3979 |
|
mWkt += QString::number( *x, 'f', 6 );
|
|
3987 |
memcpy( &x, ptr, sizeof( x ) );
|
|
3988 |
mWkt += QString::number( x, 'f', 6 );
|
3980 |
3989 |
mWkt += " ";
|
3981 |
3990 |
ptr += sizeof( double );
|
3982 |
|
y = ( double * )( ptr );
|
3983 |
|
mWkt += QString::number( *y, 'f', 6 );
|
|
3991 |
memcpy( &y, ptr, sizeof( y ) );
|
|
3992 |
mWkt += QString::number( y, 'f', 6 );
|
3984 |
3993 |
ptr += sizeof( double );
|
3985 |
3994 |
if ( hasZValue )
|
3986 |
3995 |
{
|
... | ... | |
3998 |
4007 |
QgsDebugMsg( "MULTILINESTRING found" );
|
3999 |
4008 |
unsigned char *ptr;
|
4000 |
4009 |
int idx, jdx, numLineStrings;
|
4001 |
|
int *nPoints;
|
|
4010 |
int nPoints;
|
4002 |
4011 |
|
4003 |
4012 |
mWkt += "MULTILINESTRING(";
|
4004 |
4013 |
numLineStrings = ( int )( mGeometry[5] );
|
... | ... | |
4011 |
4020 |
}
|
4012 |
4021 |
mWkt += "(";
|
4013 |
4022 |
ptr += 5; // skip type since we know its 2
|
4014 |
|
nPoints = ( int * ) ptr;
|
|
4023 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4015 |
4024 |
ptr += sizeof( int );
|
4016 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
4025 |
for ( idx = 0; idx < nPoints; idx++ )
|
4017 |
4026 |
{
|
4018 |
4027 |
if ( idx != 0 )
|
4019 |
4028 |
{
|
4020 |
4029 |
mWkt += ", ";
|
4021 |
4030 |
}
|
4022 |
|
x = ( double * ) ptr;
|
4023 |
|
mWkt += QString::number( *x, 'f', 6 );
|
|
4031 |
memcpy( &x, ptr, sizeof( x ) );
|
|
4032 |
mWkt += QString::number( x, 'f', 6 );
|
4024 |
4033 |
ptr += sizeof( double );
|
4025 |
4034 |
mWkt += " ";
|
4026 |
|
y = ( double * ) ptr;
|
4027 |
|
mWkt += QString::number( *y, 'f', 6 );
|
|
4035 |
memcpy( &y, ptr, sizeof( y ) );
|
|
4036 |
mWkt += QString::number( y, 'f', 6 );
|
4028 |
4037 |
ptr += sizeof( double );
|
4029 |
4038 |
if ( hasZValue )
|
4030 |
4039 |
{
|
... | ... | |
4044 |
4053 |
QgsDebugMsg( "MULTIPOLYGON found" );
|
4045 |
4054 |
unsigned char *ptr;
|
4046 |
4055 |
int idx, jdx, kdx;
|
4047 |
|
int *numPolygons, *numRings, *nPoints;
|
|
4056 |
int numPolygons, numRings, nPoints;
|
4048 |
4057 |
|
4049 |
4058 |
mWkt += "MULTIPOLYGON(";
|
4050 |
4059 |
ptr = mGeometry + 5;
|
4051 |
|
numPolygons = ( int * ) ptr;
|
|
4060 |
memcpy( &numPolygons, ptr, sizeof( numPolygons ) );
|
4052 |
4061 |
ptr = mGeometry + 9;
|
4053 |
|
for ( kdx = 0; kdx < *numPolygons; kdx++ )
|
|
4062 |
for ( kdx = 0; kdx < numPolygons; kdx++ )
|
4054 |
4063 |
{
|
4055 |
4064 |
if ( kdx != 0 )
|
4056 |
4065 |
{
|
... | ... | |
4058 |
4067 |
}
|
4059 |
4068 |
mWkt += "(";
|
4060 |
4069 |
ptr += 5;
|
4061 |
|
numRings = ( int * ) ptr;
|
|
4070 |
memcpy( &numRings, ptr, sizeof( numRings ) );
|
4062 |
4071 |
ptr += 4;
|
4063 |
|
for ( idx = 0; idx < *numRings; idx++ )
|
|
4072 |
for ( idx = 0; idx < numRings; idx++ )
|
4064 |
4073 |
{
|
4065 |
4074 |
if ( idx != 0 )
|
4066 |
4075 |
{
|
4067 |
4076 |
mWkt += ",";
|
4068 |
4077 |
}
|
4069 |
4078 |
mWkt += "(";
|
4070 |
|
nPoints = ( int * ) ptr;
|
|
4079 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4071 |
4080 |
ptr += 4;
|
4072 |
|
for ( jdx = 0; jdx < *nPoints; jdx++ )
|
|
4081 |
for ( jdx = 0; jdx < nPoints; jdx++ )
|
4073 |
4082 |
{
|
4074 |
4083 |
if ( jdx != 0 )
|
4075 |
4084 |
{
|
4076 |
4085 |
mWkt += ",";
|
4077 |
4086 |
}
|
4078 |
|
x = ( double * ) ptr;
|
4079 |
|
mWkt += QString::number( *x, 'f', 6 );
|
|
4087 |
memcpy( &x, ptr, sizeof( x ) );
|
|
4088 |
mWkt += QString::number( x, 'f', 6 );
|
4080 |
4089 |
ptr += sizeof( double );
|
4081 |
4090 |
mWkt += " ";
|
4082 |
|
y = ( double * ) ptr;
|
4083 |
|
mWkt += QString::number( *y, 'f', 6 );
|
|
4091 |
memcpy( &y, ptr, sizeof( y ) );
|
|
4092 |
mWkt += QString::number( y, 'f', 6 );
|
4084 |
4093 |
ptr += sizeof( double );
|
4085 |
4094 |
if ( hasZValue )
|
4086 |
4095 |
{
|
... | ... | |
4125 |
4134 |
return true;
|
4126 |
4135 |
}
|
4127 |
4136 |
|
4128 |
|
double *x;
|
4129 |
|
double *y;
|
4130 |
|
int *nPoints;
|
4131 |
|
int *numRings;
|
4132 |
|
int *numPolygons;
|
|
4137 |
double x;
|
|
4138 |
double y;
|
|
4139 |
int nPoints;
|
|
4140 |
int numRings;
|
|
4141 |
int numPolygons;
|
4133 |
4142 |
int numLineStrings;
|
4134 |
4143 |
int idx, jdx, kdx;
|
4135 |
4144 |
unsigned char *ptr;
|
... | ... | |
4147 |
4156 |
case QGis::WKBPoint25D:
|
4148 |
4157 |
case QGis::WKBPoint:
|
4149 |
4158 |
{
|
4150 |
|
x = ( double * )( mGeometry + 5 );
|
4151 |
|
y = ( double * )( mGeometry + 5 + sizeof( double ) );
|
|
4159 |
memcpy( &x, mGeometry + 5, sizeof( x ) );
|
|
4160 |
memcpy( &y, mGeometry + 5 + sizeof( double ), sizeof( x ) );
|
4152 |
4161 |
|
4153 |
|
mGeos = createGeosPoint( QgsPoint( *x, *y ) );
|
|
4162 |
mGeos = createGeosPoint( QgsPoint( x, y ) );
|
4154 |
4163 |
mDirtyGeos = false;
|
4155 |
4164 |
break;
|
4156 |
4165 |
}
|
... | ... | |
4162 |
4171 |
QVector<GEOSGeometry *> points;
|
4163 |
4172 |
|
4164 |
4173 |
ptr = mGeometry + 5;
|
4165 |
|
nPoints = ( int * ) ptr;
|
|
4174 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4166 |
4175 |
ptr = mGeometry + 1 + 2 * sizeof( int );
|
4167 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
4176 |
for ( idx = 0; idx < nPoints; idx++ )
|
4168 |
4177 |
{
|
4169 |
4178 |
ptr += ( 1 + sizeof( int ) );
|
4170 |
|
x = ( double * ) ptr;
|
|
4179 |
memcpy( &x, ptr, sizeof( x ) );
|
4171 |
4180 |
ptr += sizeof( double );
|
4172 |
|
y = ( double * ) ptr;
|
|
4181 |
memcpy( &y, ptr, sizeof( y ) );
|
4173 |
4182 |
ptr += sizeof( double );
|
4174 |
4183 |
if ( hasZValue )
|
4175 |
4184 |
{
|
4176 |
4185 |
ptr += sizeof( double );
|
4177 |
4186 |
}
|
4178 |
|
points << createGeosPoint( QgsPoint( *x, *y ) );
|
|
4187 |
points << createGeosPoint( QgsPoint( x, y ) );
|
4179 |
4188 |
}
|
4180 |
4189 |
mGeos = createGeosCollection( GEOS_MULTIPOINT, points );
|
4181 |
4190 |
mDirtyGeos = false;
|
... | ... | |
4191 |
4200 |
QgsPolyline sequence;
|
4192 |
4201 |
|
4193 |
4202 |
ptr = mGeometry + 5;
|
4194 |
|
nPoints = ( int * ) ptr;
|
|
4203 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4195 |
4204 |
ptr = mGeometry + 1 + 2 * sizeof( int );
|
4196 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
4205 |
for ( idx = 0; idx < nPoints; idx++ )
|
4197 |
4206 |
{
|
4198 |
|
x = ( double * ) ptr;
|
|
4207 |
memcpy( &x, ptr, sizeof( x ) );
|
4199 |
4208 |
ptr += sizeof( double );
|
4200 |
|
y = ( double * ) ptr;
|
|
4209 |
memcpy( &y, ptr, sizeof( y ) );
|
4201 |
4210 |
ptr += sizeof( double );
|
4202 |
4211 |
if ( hasZValue )
|
4203 |
4212 |
{
|
4204 |
4213 |
ptr += sizeof( double );
|
4205 |
4214 |
}
|
4206 |
4215 |
|
4207 |
|
sequence << QgsPoint( *x, *y );
|
|
4216 |
sequence << QgsPoint( x, y );
|
4208 |
4217 |
}
|
4209 |
4218 |
mDirtyGeos = false;
|
4210 |
4219 |
mGeos = createGeosLineString( sequence );
|
... | ... | |
4224 |
4233 |
|
4225 |
4234 |
// each of these is a wbklinestring so must handle as such
|
4226 |
4235 |
ptr += 5; // skip type since we know its 2
|
4227 |
|
nPoints = ( int * ) ptr;
|
|
4236 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4228 |
4237 |
ptr += sizeof( int );
|
4229 |
|
for ( idx = 0; idx < *nPoints; idx++ )
|
|
4238 |
for ( idx = 0; idx < nPoints; idx++ )
|
4230 |
4239 |
{
|
4231 |
|
x = ( double * ) ptr;
|
|
4240 |
memcpy( &x, ptr, sizeof( x ) );
|
4232 |
4241 |
ptr += sizeof( double );
|
4233 |
|
y = ( double * ) ptr;
|
|
4242 |
memcpy( &y, ptr, sizeof( y ) );
|
4234 |
4243 |
ptr += sizeof( double );
|
4235 |
4244 |
if ( hasZValue )
|
4236 |
4245 |
{
|
4237 |
4246 |
ptr += sizeof( double );
|
4238 |
4247 |
}
|
4239 |
|
sequence << QgsPoint( *x, *y );
|
|
4248 |
sequence << QgsPoint( x, y );
|
4240 |
4249 |
}
|
4241 |
4250 |
lines << createGeosLineString( sequence );
|
4242 |
4251 |
}
|
... | ... | |
4252 |
4261 |
QgsDebugMsgLevel( "Polygon found", 3 );
|
4253 |
4262 |
|
4254 |
4263 |
// get number of rings in the polygon
|
4255 |
|
numRings = ( int * )( mGeometry + 1 + sizeof( int ) );
|
|
4264 |
memcpy( &numRings, mGeometry + 1 + sizeof( int ), sizeof( numRings ) );
|
4256 |
4265 |
ptr = mGeometry + 1 + 2 * sizeof( int );
|
4257 |
4266 |
|
4258 |
4267 |
QVector<GEOSGeometry*> rings;
|
4259 |
4268 |
|
4260 |
|
for ( idx = 0; idx < *numRings; idx++ )
|
|
4269 |
for ( idx = 0; idx < numRings; idx++ )
|
4261 |
4270 |
{
|
4262 |
4271 |
//QgsDebugMsg("Ring nr: "+QString::number(idx));
|
4263 |
4272 |
|
4264 |
4273 |
QgsPolyline sequence;
|
4265 |
4274 |
|
4266 |
4275 |
// get number of points in the ring
|
4267 |
|
nPoints = ( int * ) ptr;
|
|
4276 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4268 |
4277 |
ptr += 4;
|
4269 |
|
for ( jdx = 0; jdx < *nPoints; jdx++ )
|
|
4278 |
for ( jdx = 0; jdx < nPoints; jdx++ )
|
4270 |
4279 |
{
|
4271 |
4280 |
// add points to a point array for drawing the polygon
|
4272 |
|
x = ( double * ) ptr;
|
|
4281 |
memcpy( &x, ptr, sizeof( x ) );
|
4273 |
4282 |
ptr += sizeof( double );
|
4274 |
|
y = ( double * ) ptr;
|
|
4283 |
memcpy( &y, ptr, sizeof( y ) );
|
4275 |
4284 |
ptr += sizeof( double );
|
4276 |
4285 |
if ( hasZValue )
|
4277 |
4286 |
{
|
4278 |
4287 |
ptr += sizeof( double );
|
4279 |
4288 |
}
|
4280 |
|
sequence << QgsPoint( *x, *y );
|
|
4289 |
sequence << QgsPoint( x, y );
|
4281 |
4290 |
}
|
4282 |
4291 |
|
4283 |
4292 |
rings << createGeosLinearRing( sequence );
|
... | ... | |
4297 |
4306 |
|
4298 |
4307 |
// get the number of polygons
|
4299 |
4308 |
ptr = mGeometry + 5;
|
4300 |
|
numPolygons = ( int * ) ptr;
|
|
4309 |
memcpy( &numPolygons, ptr, sizeof( numPolygons ) );
|
4301 |
4310 |
ptr = mGeometry + 9;
|
4302 |
|
for ( kdx = 0; kdx < *numPolygons; kdx++ )
|
|
4311 |
for ( kdx = 0; kdx < numPolygons; kdx++ )
|
4303 |
4312 |
{
|
4304 |
4313 |
//QgsDebugMsg("Polygon nr: "+QString::number(kdx));
|
4305 |
4314 |
QVector<GEOSGeometry*> rings;
|
... | ... | |
4307 |
4316 |
//skip the endian and mGeometry type info and
|
4308 |
4317 |
// get number of rings in the polygon
|
4309 |
4318 |
ptr += 5;
|
4310 |
|
numRings = ( int * ) ptr;
|
|
4319 |
memcpy( &numRings, ptr, sizeof( numRings ) );
|
4311 |
4320 |
ptr += 4;
|
4312 |
|
for ( idx = 0; idx < *numRings; idx++ )
|
|
4321 |
for ( idx = 0; idx < numRings; idx++ )
|
4313 |
4322 |
{
|
4314 |
4323 |
//QgsDebugMsg("Ring nr: "+QString::number(idx));
|
4315 |
4324 |
|
4316 |
4325 |
QgsPolyline sequence;
|
4317 |
4326 |
|
4318 |
4327 |
// get number of points in the ring
|
4319 |
|
nPoints = ( int * ) ptr;
|
|
4328 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
4320 |
4329 |
ptr += 4;
|
4321 |
|
for ( jdx = 0; jdx < *nPoints; jdx++ )
|
|
4330 |
for ( jdx = 0; jdx < nPoints; jdx++ )
|
4322 |
4331 |
{
|
4323 |
4332 |
// add points to a point array for drawing the polygon
|
4324 |
|
x = ( double * ) ptr;
|
|
4333 |
memcpy( &x, ptr, sizeof( x ) );
|
4325 |
4334 |
ptr += sizeof( double );
|
4326 |
|
y = ( double * ) ptr;
|
|
4335 |
memcpy( &y, ptr, sizeof( y ) );
|
4327 |
4336 |
ptr += sizeof( double );
|
4328 |
4337 |
if ( hasZValue )
|
4329 |
4338 |
{
|
4330 |
4339 |
ptr += sizeof( double );
|
4331 |
4340 |
}
|
4332 |
|
sequence << QgsPoint( *x, *y );
|
|
4341 |
sequence << QgsPoint( x, y );
|
4333 |
4342 |
}
|
4334 |
4343 |
|
4335 |
4344 |
rings << createGeosLinearRing( sequence );
|
... | ... | |
5834 |
5843 |
bool hasZValue = ( type == QGis::WKBMultiPoint25D );
|
5835 |
5844 |
|
5836 |
5845 |
unsigned char* ptr = mGeometry + 5;
|
5837 |
|
unsigned int nPoints = *(( int* )ptr );
|
|
5846 |
unsigned int nPoints;
|
|
5847 |
memcpy( &nPoints, ptr, sizeof( nPoints ) );
|
5838 |
5848 |
ptr += 4;
|
5839 |
5849 |
|
5840 |
5850 |
QgsMultiPoint points( nPoints );
|
... | ... | |
5855 |
5865 |
bool hasZValue = ( type == QGis::WKBMultiLineString25D );
|
5856 |
5866 |
|
5857 |
5867 |
unsigned char* ptr = mGeometry + 5;
|
5858 |
|
unsigned int numLineStrings = *(( int* )ptr );
|
|
5868 |
unsigned int numLineStrings;
|
|
5869 |
memcpy( &numLineStrings, ptr, sizeof( numLineStrings ) );
|
5859 |
5870 |
ptr += 4;
|
5860 |
5871 |
|
5861 |
5872 |
QgsMultiPolyline lines( numLineStrings );
|
... | ... | |
5877 |
5888 |
bool hasZValue = ( type == QGis::WKBMultiPolygon25D );
|
5878 |
5889 |
|
5879 |
5890 |
unsigned char* ptr = mGeometry + 5;
|
5880 |
|
unsigned int numPolygons = *(( int* )ptr );
|
|
5891 |
unsigned int numPolygons;
|
|
5892 |
memcpy( &numPolygons, ptr, sizeof( numPolygons ) );
|
5881 |
5893 |
ptr += 4;
|
5882 |
5894 |
|
5883 |
5895 |
QgsMultiPolygon polygons( numPolygons );
|