コード例 #1
0
        public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out string val, int index, int count)
        {
            val = null;
            if (count < 0)
            {
                return(0);
            }

            if (!gtif.gt_keys.ContainsKey(thekey))
            {
                return(0);
            }
            GeoKey key = gtif.gt_keys[thekey];

            if (key.gk_type != tagtype_t.TYPE_ASCII)
            {
                return(0);
            }

            string val_ = (string)key.gk_data;

            if (count == 0 || (count + index) > val_.Length)
            {
                val = val_.Substring(index);
            }
            else
            {
                val = val_.Substring(index, count);
            }

            return(val.Length);
        }
コード例 #2
0
        public static void GTIFPrint(GTIF gtif, GTIFPrintMethod print, object aux)
        {
            if (print == null)
            {
                print = DefaultPrint;
            }
            if (aux == null)
            {
                aux = Console.Out;
            }

            string message = FMT_GEOTIFF + "\n"; print(message, aux);

            message = string.Format("\t" + FMT_VERSION + "\n", gtif.gt_version); print(message, aux);
            message = string.Format("\t" + FMT_REV + "\n", gtif.gt_rev_major, gtif.gt_rev_minor); print(message, aux);
            message = string.Format("\t{0}\n", FMT_TAGS); print(message, aux);

            PrintGeoTags(gtif, print, aux);

            message = string.Format("\t\t{0}\n", FMT_TAGEND); print(message, aux);
            message = string.Format("\t{0}\n", FMT_KEYS); print(message, aux);

            foreach (GeoKey key in gtif.gt_keys.Values)
            {
                PrintKey(key, print, aux);
            }

            message = string.Format("\t\t{0}\n", FMT_KEYEND); print(message, aux);
            message = string.Format("\t{0}\n", FMT_GEOEND); print(message, aux);
        }
コード例 #3
0
        static void PrintGeoTags(GTIF gt, GTIFPrintMethod print, object aux)
        {
            TIFF tif = gt.gt_tif;

            if (tif == null)
            {
                return;
            }

            object data;
            int    count;

            if (gt.gt_methods.get(tif, (ushort)GTIFF_TIEPOINTS, out count, out data))
            {
                PrintTag((int)GTIFF_TIEPOINTS, count / 3, (double[])data, 3, print, aux);
            }

            if (gt.gt_methods.get(tif, (ushort)GTIFF_PIXELSCALE, out count, out data))
            {
                PrintTag((int)GTIFF_PIXELSCALE, count / 3, (double[])data, 3, print, aux);
            }

            if (gt.gt_methods.get(tif, (ushort)GTIFF_TRANSMATRIX, out count, out data))
            {
                PrintTag((int)GTIFF_TRANSMATRIX, count / 4, (double[])data, 4, print, aux);
            }
        }
コード例 #4
0
        public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out double[] val, int index, int count)
        {
            val = null;
            if (!gtif.gt_keys.ContainsKey(thekey))
            {
                return(0);
            }
            GeoKey key = gtif.gt_keys[thekey];

            if (key.gk_type != tagtype_t.TYPE_DOUBLE)
            {
                return(0);
            }

            double[] val_ = (double[])key.gk_data;
            if (count == 0 || (count + index) > val_.Length)
            {
                count = val_.Length - index;
            }
            if (count <= 0)
            {
                return(0);
            }
            val = new double[count];
            Array.Copy(val_, index, val, 0, count);
            return(count);
        }
コード例 #5
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyInfo(GTIF gtif, geokey_t key, out tagtype_t type)
		{
			type=tagtype_t.TYPE_UNKNOWN;
			if(!gtif.gt_keys.ContainsKey(key)) return 0;
			GeoKey keyptr=gtif.gt_keys[key];
			type=keyptr.gk_type;
			return keyptr.gk_count;
		}
コード例 #6
0
        //*********************************************************************
        //
        //							Public Routines
        //
        //*********************************************************************

        // This function deallocates an existing GeoTIFF access handle previously
        // created with GTIFNew(). If the handle was
        // used to write GeoTIFF keys to the TIFF file, the
        // GTIFWriteKeys() function should be used
        // to flush results to the file before calling GTIFFree(). GTIFFree()
        // should be called before XTIFFClose() is
        // called on the corresponding TIFF file handle.
        public static void GTIFFree(GTIF gtif)
        {
            if (gtif == null)
            {
                return;
            }
            gtif.gt_keys.Clear();
        }
コード例 #7
0
 // return the Header info of this geotiff file
 public static void GTIFDirectoryInfo(GTIF gtif, int[] version, out int keycount)
 {
     if (version != null && version.Length >= 3)
     {
         version[0] = gtif.gt_version;
         version[1] = gtif.gt_rev_major;
         version[2] = gtif.gt_rev_minor;
     }
     keycount = gtif.gt_keys.Count;
 }
コード例 #8
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		// return the Header info of this geotiff file
		public static void GTIFDirectoryInfo(GTIF gtif, int[] version, out int keycount)
		{
			if(version!=null&&version.Length>=3)
			{
				version[0]=gtif.gt_version;
				version[1]=gtif.gt_rev_major;
				version[2]=gtif.gt_rev_minor;
			}
			keycount=gtif.gt_keys.Count;
		}
コード例 #9
0
 public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out vdatum_t val, int index, int count)
 {
     // ignore count
     val = 0;
     ushort[] vals;
     if (GTIFKeyGet(gtif, thekey, out vals, index, 1) == 0)
     {
         return(0);
     }
     val = (vdatum_t)vals[0];
     return(1);
 }
コード例 #10
0
 public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out double val, int index, int count)
 {
     // ignore count
     val = 0;
     double[] vals;
     if (GTIFKeyGet(gtif, thekey, out vals, index, 1) == 0)
     {
         return(0);
     }
     val = vals[0];
     return(1);
 }
コード例 #11
0
        public static int GTIFKeyInfo(GTIF gtif, geokey_t key, out tagtype_t type)
        {
            type = tagtype_t.TYPE_UNKNOWN;
            if (!gtif.gt_keys.ContainsKey(key))
            {
                return(0);
            }
            GeoKey keyptr = gtif.gt_keys[key];

            type = keyptr.gk_type;
            return(keyptr.gk_count);
        }
コード例 #12
0
		static void PrintGeoTags(GTIF gt, GTIFPrintMethod print, object aux)
		{
			TIFF tif=gt.gt_tif;
			if(tif==null) return;

			object data;
			int count;

			if(gt.gt_methods.get(tif, (ushort)GTIFF_TIEPOINTS, out count, out data))
				PrintTag((int)GTIFF_TIEPOINTS, count/3, (double[])data, 3, print, aux);

			if(gt.gt_methods.get(tif, (ushort)GTIFF_PIXELSCALE, out count, out data))
				PrintTag((int)GTIFF_PIXELSCALE, count/3, (double[])data, 3, print, aux);

			if(gt.gt_methods.get(tif, (ushort)GTIFF_TRANSMATRIX, out count, out data))
				PrintTag((int)GTIFF_TRANSMATRIX, count/4, (double[])data, 4, print, aux);
		}
コード例 #13
0
        public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out string val)
        {
            val = null;
            if (!gtif.gt_keys.ContainsKey(thekey))
            {
                return(0);
            }
            GeoKey key = gtif.gt_keys[thekey];

            if (key.gk_type != tagtype_t.TYPE_ASCII)
            {
                return(0);
            }

            val = (string)key.gk_data;

            return(val.Length);
        }
コード例 #14
0
		public static void GTIFPrint(GTIF gtif, GTIFPrintMethod print, object aux)
		{
			if(print==null) print=DefaultPrint;
			if(aux==null) aux=Console.Out;

			string message=FMT_GEOTIFF+"\n"; print(message, aux);
			message=string.Format("\t"+FMT_VERSION+"\n", gtif.gt_version); print(message, aux);
			message=string.Format("\t"+FMT_REV+"\n", gtif.gt_rev_major, gtif.gt_rev_minor); print(message, aux);
			message=string.Format("\t{0}\n", FMT_TAGS); print(message, aux);

			PrintGeoTags(gtif, print, aux);

			message=string.Format("\t\t{0}\n", FMT_TAGEND); print(message, aux);
			message=string.Format("\t{0}\n", FMT_KEYS); print(message, aux);

			foreach(GeoKey key in gtif.gt_keys.Values) PrintKey(key, print, aux);

			message=string.Format("\t\t{0}\n", FMT_KEYEND); print(message, aux);
			message=string.Format("\t{0}\n", FMT_GEOEND); print(message, aux);
		}
コード例 #15
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
        public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, double[] val)
        {
            if (val == null)          // delete the indicated tag
            {
                if (!gtif.gt_keys.ContainsKey(keyID))
                {
                    return(false);
                }
                gtif.gt_keys.Remove(keyID);
                gtif.gt_flags |= gtiff_flags.FLAG_FILE_MODIFIED;
                return(true);
            }

            if (gtif.gt_keys.ContainsKey(keyID))
            {
                gtif.gt_keys.Remove(keyID);
                gtif.gt_flags |= gtiff_flags.FLAG_FILE_MODIFIED;
            }

            // We need to create the key
            try
            {
                GeoKey key = new GeoKey();
                key.gk_key   = keyID;
                key.gk_type  = tagtype_t.TYPE_DOUBLE;
                key.gk_count = val.Length;

                double[] tmp = new double[val.Length];
                val.CopyTo(tmp, 0);
                key.gk_data = tmp;

                gtif.gt_keys.Add(keyID, key);
                gtif.gt_flags |= gtiff_flags.FLAG_FILE_MODIFIED;
                return(true);
            }
            catch
            {
                return(false);
            }
        }
コード例 #16
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
        public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, string val)
        {
            if (val == null)          // delete the indicated tag
            {
                if (!gtif.gt_keys.ContainsKey(keyID))
                {
                    return(false);
                }
                gtif.gt_keys.Remove(keyID);
                gtif.gt_flags |= gtiff_flags.FLAG_FILE_MODIFIED;
                return(true);
            }

            if (gtif.gt_keys.ContainsKey(keyID))
            {
                gtif.gt_keys.Remove(keyID);
                gtif.gt_flags |= gtiff_flags.FLAG_FILE_MODIFIED;
            }

            val = val.Trim('\0');

            // We need to create the key
            try
            {
                GeoKey key = new GeoKey();
                key.gk_key   = keyID;
                key.gk_type  = tagtype_t.TYPE_ASCII;
                key.gk_count = val.Length;
                key.gk_data  = val.Substring(0, val.Length);
                gtif.gt_keys.Add(keyID, key);
                gtif.gt_flags |= gtiff_flags.FLAG_FILE_MODIFIED;
                return(true);
            }
            catch
            {
                return(false);
            }
        }
コード例 #17
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
 public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, double val)
 {
     double[] val1 = new double[] { val };
     return(GTIFKeySet(gtif, keyID, val1));
 }
コード例 #18
0
ファイル: geo_trans.cs プロジェクト: plynkus/libgeotiff.net
        //***********************************************************************/
        //*							GTIFPCSToImage()							*/
        //***********************************************************************/

        // Translate a projection coordinate to pixel/line coordinates.
        //
        // At this time this function does not support PCS to image translations for
        // tiepoints-only based definitions, only matrix and pixelscale/tiepoints
        // formulations are supposed.
        //
        // @param gtif The handle from GTIFNew() indicating the target file.
        // @param x A reference to the double containing the pixel offset on input,
        // and into which the easting/longitude will be put on completion.
        // @param y A reference to the double containing the line offset on input,
        // and into which the northing/latitude will be put on completion.
        //
        // @return true if the transformation succeeds, or false if it fails. It may
        // fail if the file doesn't have properly setup transformation information,
        // or it is in a form unsupported by this function.
        public static bool GTIFPCSToImage(GTIF gtif, ref double x, ref double y)
        {
            bool result = false;
            int  tiepoint_count, count, transform_count;
            TIFF tif = gtif.gt_tif;

            double[] tiepoints   = null;
            double[] pixel_scale = null;
            double[] transform   = null;

            // --------------------------------------------------------------------
            //		Fetch tiepoints and pixel scale.
            // --------------------------------------------------------------------
            object ap;

            if (!gtif.gt_methods.get(tif, (ushort)GTIFF_TIEPOINTS, out tiepoint_count, out ap))
            {
                tiepoint_count = 0;
            }
            else if (ap is double[])
            {
                tiepoints = (double[])ap;
            }

            if (!gtif.gt_methods.get(tif, (ushort)GTIFF_PIXELSCALE, out count, out ap))
            {
                count = 0;
            }
            else if (ap is double[])
            {
                pixel_scale = (double[])ap;
            }

            if (!gtif.gt_methods.get(tif, (ushort)GTIFF_TRANSMATRIX, out transform_count, out ap))
            {
                transform_count = 0;
            }
            else if (ap is double[])
            {
                transform = (double[])ap;
            }

            // --------------------------------------------------------------------
            //		Handle matrix - convert to "geotransform" format, invert and
            //		apply.
            // --------------------------------------------------------------------
            if (transform_count == 16)
            {
                double   x_in = x, y_in = y;
                double[] gt_in  = new double[6];
                double[] gt_out = new double[6];

                gt_in[0] = transform[0];
                gt_in[1] = transform[1];
                gt_in[2] = transform[3];
                gt_in[3] = transform[4];
                gt_in[4] = transform[5];
                gt_in[5] = transform[7];

                if (!inv_geotransform(gt_in, gt_out))
                {
                    result = false;
                }
                else
                {
                    x = x_in * gt_out[0] + y_in * gt_out[1] + gt_out[2];
                    y = x_in * gt_out[3] + y_in * gt_out[4] + gt_out[5];

                    result = true;
                }
            }
            // --------------------------------------------------------------------
            //		If the pixelscale count is zero, but we have tiepoints use
            //		the tiepoint based approach.
            // --------------------------------------------------------------------
            else if (tiepoint_count > 6 && count == 0)
            {
                result = GTIFTiepointTranslate(tiepoint_count / 6, tiepoints, 3, tiepoints, 0, ref x, ref y);
            }
            // --------------------------------------------------------------------
            //		For now we require one tie point, and a valid pixel scale.
            // --------------------------------------------------------------------
            else if (count >= 3 && tiepoint_count >= 6)
            {
                x = (x - tiepoints[3]) / pixel_scale[0] + tiepoints[0];
                y = (y - tiepoints[4]) / (-1 * pixel_scale[1]) + tiepoints[1];

                result = true;
            }

            return(result);
        }
コード例 #19
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out vdatum_t val, int index, int count)
		{
			// ignore count
			val=0;
			ushort[] vals;
			if(GTIFKeyGet(gtif, thekey, out vals, index, 1)==0) return 0;
			val=(vdatum_t)vals[0];
			return 1;
		}
コード例 #20
0
 // Print off the directory info, using whatever method is specified
 // (defaults to fprintf if null). The "aux" parameter is provided for user
 // defined method for passing parameters or whatever.
 //
 // The output format is a "GeoTIFF meta-data" file, which may be
 // used to import information with the GTIFFImport() routine.
 public static void GTIFPrint(GTIF gtif)
 {
     GTIFPrint(gtif, null, null);
 }
コード例 #21
0
        static int ReadTag(GTIF gt, GTIFReadMethod scan, object aux)
        {
            string message = scan(aux);

            if (message == null)
            {
                return(-1);
            }
            if (message.Length >= 12)
            {
                if (message.ToLower().Substring(0, 12) == FMT_TAGEND.ToLower().Substring(0, 12))
                {
                    return(0);
                }
            }

            try
            {
                int firstp = message.IndexOfAny(new char[] { '(', ' ', '\t' });
                if (firstp < 0)
                {
                    return(StringError(message));
                }

                string tagname = message.Substring(0, firstp).Trim();
                message = message.Substring(firstp);

                int colon = message.IndexOf(':');
                if (colon < 0)
                {
                    return(StringError(message));
                }

                message = message.Substring(0, colon);
                message = message.Trim(' ', '\t', '(', ')');

                string[] spl = message.Split(',');
                if (spl.Length != 2)
                {
                    return(StringError(message));
                }

                int nrows = int.Parse(spl[0]);
                int ncols = int.Parse(spl[1]);

                int tag = GTIFTagCode(tagname);
                if (tag < 0)
                {
                    return(StringError(tagname));
                }

                int count = nrows * ncols;

                double[] dptr = new double[count];

                for (int i = 0; i < nrows; i++)
                {
                    message = scan(aux);
                    if (message == null)
                    {
                        return(-1);
                    }

                    spl = message.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                    if (spl.Length != ncols)
                    {
                        StringError(message);
                    }

                    for (int j = 0; j < ncols; j++)
                    {
                        message             = spl[j];
                        dptr[i * ncols + j] = GTIFAtof(message);
                    }
                }
                gt.gt_methods.set(gt.gt_tif, (ushort)tag, count, dptr);
            }
            catch
            {
                return(StringError(message));
            }

            return(1);
        }
コード例 #22
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, double[] val)
		{
			if(val==null) // delete the indicated tag
			{
				if(!gtif.gt_keys.ContainsKey(keyID)) return false;
				gtif.gt_keys.Remove(keyID);
				gtif.gt_flags|=gtiff_flags.FLAG_FILE_MODIFIED;
				return true;
			}

			if(gtif.gt_keys.ContainsKey(keyID))
			{
				gtif.gt_keys.Remove(keyID);
				gtif.gt_flags|=gtiff_flags.FLAG_FILE_MODIFIED;
			}
			
			// We need to create the key
			try
			{
				GeoKey key=new GeoKey();
				key.gk_key=keyID;
				key.gk_type=tagtype_t.TYPE_DOUBLE;
				key.gk_count=val.Length;

				double[] tmp=new double[val.Length];
				val.CopyTo(tmp, 0);
				key.gk_data=tmp;

				gtif.gt_keys.Add(keyID, key);
				gtif.gt_flags|=gtiff_flags.FLAG_FILE_MODIFIED;
				return true;
			}
			catch
			{
				return false;
			}
		}
コード例 #23
0
		public static bool GTIFImport(GTIF gtif, GTIFReadMethod scan, object aux)
		{
			if(scan==null) scan=DefaultRead;
			if(aux==null) aux=Console.In;

			string message=scan(aux);
			if(message==null||message.Length<20) return false;
			if(message.ToLower().Substring(0, 20)!=FMT_GEOTIFF.ToLower().Substring(0, 20)) return false;

			message=scan(aux);
			if(message==null||message.Length<10) return false;
			if(message.ToLower().Substring(0, 8)!=FMT_VERSION.ToLower().Substring(0, 8)) return false;
			message=message.Substring(9);
			try
			{
				gtif.gt_version=ushort.Parse(message);
			}
			catch
			{
				return false;
			}

			message=scan(aux);
			if(message==null||message.Length<15) return false;
			if(message.ToLower().Substring(0, 13)!=FMT_REV.ToLower().Substring(0, 13)) return false;
			message=message.Substring(14);
			try
			{
				string[] spl=message.Split('.');
				if(spl.Length!=2) return false;
				gtif.gt_rev_major=ushort.Parse(spl[0]);
				gtif.gt_rev_minor=ushort.Parse(spl[1]);
			}
			catch
			{
				return false;
			}

			message=scan(aux);
			if(message==null||message.Length<19) return false;
			if(message.ToLower().Substring(0, 19)!=FMT_TAGS.ToLower().Substring(0, 19)) return false;

			int status;
			while((status=ReadTag(gtif, scan, aux))>0) ;
			if(status<0) return false;

			message=scan(aux);
			if(message==null||message.Length<18) return false;
			if(message.ToLower().Substring(0, 18)!=FMT_KEYS.ToLower().Substring(0, 18)) return false;

			while((status=ReadKey(gtif, scan, aux))>0) ;
			return (status==0); // success
		}
コード例 #24
0
		//***********************************************************************
		//								GTIFSetFromProj4()
		//***********************************************************************
		static bool GTIFSetFromProj4(GTIF gtif, string proj4)
		{
			Dictionary<string, string> papszNV=OSRProj4Tokenize(proj4);
			short nSpheroid=KvUserDefined;
			double dfSemiMajor=0.0, dfSemiMinor=0.0, dfInvFlattening=0.0;
			int nDatum=KvUserDefined;
			int nGCS=KvUserDefined;
			string value;

			// --------------------------------------------------------------------
			//		Get the ellipsoid definition.
			// --------------------------------------------------------------------
			value=OSR_GSV(papszNV, "ellps");
			if(value!=null) value=value.ToLower();

			if(value==null)
			{
			}
			else if(value=="WGS84") nSpheroid=(short)ellipsoid_t.Ellipse_WGS_84;
			else if(value=="clrk66") nSpheroid=(short)ellipsoid_t.Ellipse_Clarke_1866;
			else if(value=="clrk80") nSpheroid=(short)ellipsoid_t.Ellipse_Clarke_1880;
			else if(value=="GRS80") nSpheroid=(short)ellipsoid_t.Ellipse_GRS_1980;

			if(nSpheroid==KvUserDefined)
			{
				dfSemiMajor=OSR_GDV(papszNV, "a", 0.0);
				dfSemiMinor=OSR_GDV(papszNV, "b", 0.0);
				dfInvFlattening=OSR_GDV(papszNV, "rf", 0.0);
				if(dfSemiMinor!=0.0&&dfInvFlattening==0.0)
					dfInvFlattening=-1.0/(dfSemiMinor/dfSemiMajor-1.0);
			}

			// --------------------------------------------------------------------
			//		Get the GCS/Datum code.
			// --------------------------------------------------------------------
			value=OSR_GSV(papszNV, "datum");
			if(value!=null) value=value.ToLower();

			if(value==null)
			{
			}
			else if(value=="WGS84")
			{
				nGCS=(int)geographic_t.GCS_WGS_84;
				nDatum=(int)geodeticdatum_t.Datum_WGS84;
			}
			else if(value=="NAD83")
			{
				nGCS=(int)geographic_t.GCS_NAD83;
				nDatum=(int)geodeticdatum_t.Datum_North_American_Datum_1983;
			}
			else if(value=="NAD27")
			{
				nGCS=(int)geographic_t.GCS_NAD27;
				nDatum=(int)geodeticdatum_t.Datum_North_American_Datum_1927;
			}

			// --------------------------------------------------------------------
			//		Operate on the basis of the projection name.
			// --------------------------------------------------------------------
			value=OSR_GSV(papszNV, "proj");
			if(value!=null) value=value.ToLower();

			if(value==null)
			{
				OSRFreeStringList(papszNV);
				return false;
			}
			else if(value=="longlat"||value=="latlong")
			{
			}
			else if(value=="tmerc")
			{
				GTIFKeySet(gtif, geokey_t.GTModelTypeGeoKey, (ushort)modeltype_t.ModelTypeProjected);
				GTIFKeySet(gtif, geokey_t.ProjectedCSTypeGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjectionGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjCoordTransGeoKey, (ushort)coordtrans_t.CT_TransverseMercator);
				GTIFKeySet(gtif, geokey_t.ProjNatOriginLatGeoKey, OSR_GDV(papszNV, "lat_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjNatOriginLongGeoKey, OSR_GDV(papszNV, "lon_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, OSR_GDV(papszNV, "k", 1.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseEastingGeoKey, OSR_GDV(papszNV, "x_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseNorthingGeoKey, OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="utm")
			{
				int nZone=(int)OSR_GDV(papszNV, "zone", 0);
				string south=OSR_GSV(papszNV, "south");
				GTIFKeySet(gtif, geokey_t.GTModelTypeGeoKey, (ushort)modeltype_t.ModelTypeProjected);
				GTIFKeySet(gtif, geokey_t.ProjectedCSTypeGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjectionGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjCoordTransGeoKey, (ushort)coordtrans_t.CT_TransverseMercator);
				GTIFKeySet(gtif, geokey_t.ProjNatOriginLatGeoKey, 0.0);
				GTIFKeySet(gtif, geokey_t.ProjNatOriginLongGeoKey, nZone*6-183.0);
				GTIFKeySet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, 0.9996);
				GTIFKeySet(gtif, geokey_t.ProjFalseEastingGeoKey, 500000.0);
				if(south!=null) GTIFKeySet(gtif, geokey_t.ProjFalseNorthingGeoKey, (south!=null)?10000000.0:0.0);
			}
			else if(value=="lcc"&&OSR_GDV(papszNV, "lat_0", 0.0)==OSR_GDV(papszNV, "lat_1", 0.0))
			{
				GTIFKeySet(gtif, geokey_t.GTModelTypeGeoKey, (ushort)modeltype_t.ModelTypeProjected);
				GTIFKeySet(gtif, geokey_t.ProjectedCSTypeGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjectionGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjCoordTransGeoKey, (ushort)coordtrans_t.CT_LambertConfConic_1SP);
				GTIFKeySet(gtif, geokey_t.ProjNatOriginLatGeoKey, OSR_GDV(papszNV, "lat_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjNatOriginLongGeoKey, OSR_GDV(papszNV, "lon_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, OSR_GDV(papszNV, "k", 1.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseEastingGeoKey, OSR_GDV(papszNV, "x_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseNorthingGeoKey, OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="lcc")
			{
				GTIFKeySet(gtif, geokey_t.GTModelTypeGeoKey, (ushort)modeltype_t.ModelTypeProjected);
				GTIFKeySet(gtif, geokey_t.ProjectedCSTypeGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjectionGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.ProjCoordTransGeoKey, (ushort)coordtrans_t.CT_LambertConfConic_2SP);
				GTIFKeySet(gtif, geokey_t.ProjFalseOriginLatGeoKey, OSR_GDV(papszNV, "lat_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseOriginLongGeoKey, OSR_GDV(papszNV, "lon_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjStdParallel1GeoKey, OSR_GDV(papszNV, "lat_1", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjStdParallel2GeoKey, OSR_GDV(papszNV, "lat_2", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseOriginEastingGeoKey, OSR_GDV(papszNV, "x_0", 0.0));
				GTIFKeySet(gtif, geokey_t.ProjFalseOriginNorthingGeoKey, OSR_GDV(papszNV, "y_0", 0.0));
			}
#if notdef
			else if(value=="bonne")
			{
				SetBonne(OSR_GDV(papszNV, "lat_1", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="cass")
			{
				SetCS(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="nzmg")
			{
				SetNZMG(OSR_GDV(papszNV, "lat_0", -41.0),
					OSR_GDV(papszNV, "lon_0", 173.0),
					OSR_GDV(papszNV, "x_0", 2510000.0),
					OSR_GDV(papszNV, "y_0", 6023150.0));
			}
			else if(value=="cea")
			{
				SetCEA(OSR_GDV(papszNV, "lat_ts", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="merc"&&OSR_GDV(papszNV, "lat_ts", 1000.0)<999.0) // 2SP form
			{
				SetMercator2SP(OSR_GDV(papszNV, "lat_ts", 0.0),
					0.0,
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="merc") // 1SP form
			{
				SetMercator(0.0,
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="stere"&&Math.Abs(OSR_GDV(papszNV, "lat_0", 0.0)-90)<0.001)
			{
				SetPS(OSR_GDV(papszNV, "lat_ts", 90.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="stere"&&Math.Abs(OSR_GDV(papszNV, "lat_0", 0.0)+90)<0.001)
			{
				SetPS(OSR_GDV(papszNV, "lat_ts", -90.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value.StartsWith("stere")&&OSR_GSV(papszNV, "k")!=null) // mostly sterea
			{
				SetOS(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="stere")
			{
				SetStereographic(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					1.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="eqc")
			{
				if(OSR_GDV(papszNV, "lat_0", 0.0)!=OSR_GDV(papszNV, "lat_ts", 0.0))
					SetEquirectangular2(OSR_GDV(papszNV, "lat_0", 0.0),
						OSR_GDV(papszNV, "lon_0", 0.0)+dfFromGreenwich,
						OSR_GDV(papszNV, "lat_ts", 0.0),
						OSR_GDV(papszNV, "x_0", 0.0),
						OSR_GDV(papszNV, "y_0", 0.0));
				else
					SetEquirectangular(OSR_GDV(papszNV, "lat_ts", 0.0),
						OSR_GDV(papszNV, "lon_0", 0.0)+dfFromGreenwich,
						OSR_GDV(papszNV, "x_0", 0.0),
						OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="glabsgm")
			{
				SetGaussLabordeReunion(OSR_GDV(papszNV, "lat_0", -21.116666667),
					OSR_GDV(papszNV, "lon_0", 55.53333333309)+dfFromGreenwich,
					OSR_GDV(papszNV, "k_0", 1.0),
					OSR_GDV(papszNV, "x_0", 160000.000),
					OSR_GDV(papszNV, "y_0", 50000.000));
			}
			else if(value=="gnom")
			{
				SetGnomonic(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="ortho")
			{
				SetOrthographic(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="laea")
			{
				SetLAEA(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="aeqd")
			{
				SetAE(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="eqdc")
			{
				SetEC(OSR_GDV(papszNV, "lat_1", 0.0),
					OSR_GDV(papszNV, "lat_2", 0.0),
					OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="mill")
			{
				SetMC(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="moll")
			{
				SetMollweide(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="eck4")
			{
				SetEckertIV(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="eck6")
			{
				SetEckertVI(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="poly")
			{
				SetPolyconic(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="aea")
			{
				SetACEA(OSR_GDV(papszNV, "lat_1", 0.0),
					OSR_GDV(papszNV, "lat_2", 0.0),
					OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="robin")
			{
				SetRobinson(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="vandg")
			{
				SetVDG(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="sinu")
			{
				SetSinusoidal(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="gall")
			{
				SetGS(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="goode")
			{
				SetGH(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="geos")
			{
				SetGEOS(OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "h", 35785831.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="lcc")
			{
				if(OSR_GDV(papszNV, "lat_0", 0.0)==OSR_GDV(papszNV, "lat_1", 0.0))
				{
					// 1SP form
					SetLCC1SP(OSR_GDV(papszNV, "lat_0", 0.0),
						OSR_GDV(papszNV, "lon_0", 0.0),
						OSR_GDV(papszNV, "k_0", 1.0),
						OSR_GDV(papszNV, "x_0", 0.0),
						OSR_GDV(papszNV, "y_0", 0.0));
				}
				else
				{
					// 2SP form
					SetLCC(OSR_GDV(papszNV, "lat_1", 0.0),
						OSR_GDV(papszNV, "lat_2", 0.0),
						OSR_GDV(papszNV, "lat_0", 0.0),
						OSR_GDV(papszNV, "lon_0", 0.0),
						OSR_GDV(papszNV, "x_0", 0.0),
						OSR_GDV(papszNV, "y_0", 0.0));
				}
			}
			else if(value=="omerc")
			{
				SetHOM(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lonc", 0.0),
					OSR_GDV(papszNV, "alpha", 0.0),
					0.0, // ???
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="somerc")
			{
				SetHOM(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					90.0, 90.0,
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="krovak")
			{
				SetKrovak(OSR_GDV(papszNV, "lat_0", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "alpha", 0.0),
					0.0, // pseudo_standard_parallel_1
					OSR_GDV(papszNV, "k", 1.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="iwm_p")
			{
				SetIWMPolyconic(OSR_GDV(papszNV, "lat_1", 0.0),
					OSR_GDV(papszNV, "lat_2", 0.0),
					OSR_GDV(papszNV, "lon_0", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag1")
			{
				SetWagner(1, 0.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag2")
			{
				SetWagner(2, 0.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag3")
			{
				SetWagner(3,
					OSR_GDV(papszNV, "lat_ts", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag1")
			{
				SetWagner(4, 0.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag1")
			{
				SetWagner(5, 0.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag1")
			{
				SetWagner(6, 0.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="wag1")
			{
				SetWagner(7, 0.0,
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
			else if(value=="tpeqd")
			{
				SetTPED(OSR_GDV(papszNV, "lat_1", 0.0),
					OSR_GDV(papszNV, "lon_1", 0.0),
					OSR_GDV(papszNV, "lat_2", 0.0),
					OSR_GDV(papszNV, "lon_2", 0.0),
					OSR_GDV(papszNV, "x_0", 0.0),
					OSR_GDV(papszNV, "y_0", 0.0));
			}
#endif
			else
			{
				// unsupported coordinate system
				OSRFreeStringList(papszNV);
				return false;
			}

			// --------------------------------------------------------------------
			//		Write the GCS if we have it, otherwise write the datum.
			// --------------------------------------------------------------------
			if(nGCS!=KvUserDefined)
			{
				GTIFKeySet(gtif, geokey_t.GeographicTypeGeoKey, (ushort)nGCS);
			}
			else
			{
				GTIFKeySet(gtif, geokey_t.GeographicTypeGeoKey, (ushort)KvUserDefined);
				GTIFKeySet(gtif, geokey_t.GeogGeodeticDatumGeoKey, (ushort)nDatum);
			}

			// --------------------------------------------------------------------
			//		Write the ellipsoid if we don't know the GCS.
			// --------------------------------------------------------------------
			if(nGCS==KvUserDefined)
			{
				if(nSpheroid!=KvUserDefined) GTIFKeySet(gtif, geokey_t.GeogEllipsoidGeoKey, (ushort)nSpheroid);
				else
				{
					GTIFKeySet(gtif, geokey_t.GeogEllipsoidGeoKey, (ushort)KvUserDefined);
					GTIFKeySet(gtif, geokey_t.GeogSemiMajorAxisGeoKey, dfSemiMajor);
					if(dfInvFlattening==0.0) GTIFKeySet(gtif, geokey_t.GeogSemiMinorAxisGeoKey, dfSemiMajor);
					else GTIFKeySet(gtif, geokey_t.GeogInvFlatteningGeoKey, dfInvFlattening);
				}
			}

			// --------------------------------------------------------------------
			//		Linear units translation
			// --------------------------------------------------------------------
			value=OSR_GSV(papszNV, "units");
			if(value!=null) value=value.ToLower();

			if(value==null)
			{
				value=OSR_GSV(papszNV, "to_meter");
				if(value!=null)
				{
					GTIFKeySet(gtif, geokey_t.ProjLinearUnitsGeoKey, (ushort)KvUserDefined);
					GTIFKeySet(gtif, geokey_t.ProjLinearUnitSizeGeoKey, GTIFAtof(value));
				}
			}
			else if(value=="meter"||value=="m")
			{
				GTIFKeySet(gtif, geokey_t.ProjLinearUnitsGeoKey, (ushort)geounits_t.Linear_Meter);
			}
			else if(value=="us-ft")
			{
				GTIFKeySet(gtif, geokey_t.ProjLinearUnitsGeoKey, (ushort)geounits_t.Linear_Foot_US_Survey);
			}
			else if(value=="ft")
			{
				GTIFKeySet(gtif, geokey_t.ProjLinearUnitsGeoKey, (ushort)geounits_t.Linear_Foot);
			}

			OSRFreeStringList(papszNV);

			return true;
		}
コード例 #25
0
 public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out primemeridian_t val, int index)
 {
     return(GTIFKeyGet(gtif, thekey, out val, index, 0));
 }
コード例 #26
0
		// This function flushes all the GeoTIFF keys that have been set with the 
		// GTIFKeySet() function into the associated 
		// TIFF file.
		//
		// @param gt The GeoTIFF handle returned by GTIFNew.
		//
		// GTIFWriteKeys() should be called before
		// GTIFFree() is used to deallocate a GeoTIFF access handle.
		public static bool GTIFWriteKeys(GTIF gt)
		{
			if((gt.gt_flags&gtiff_flags.FLAG_FILE_MODIFIED)==0) return true;
			if(gt.gt_tif==null) return false;

			List<geokey_t> keys=new List<geokey_t>(gt.gt_keys.Keys);
			keys.Sort();

			List<ushort> shorts=new List<ushort>();
			List<ushort> shortsValues=new List<ushort>();
			List<double> doubles=new List<double>();
			string strings="";

			// Set up header of ProjectionInfo tag
			shorts.Add((ushort)GvCurrentVersion);
			shorts.Add((ushort)GvCurrentRevision);
			shorts.Add((ushort)GvCurrentMinorRev);
			shorts.Add((ushort)keys.Count);

			int shortOffset=4+keys.Count*4;

			foreach(geokey_t key in keys)
			{
				GeoKey keyptr=gt.gt_keys[key];
				if(keyptr.gk_type==tagtype_t.TYPE_ASCII)
				{
					string str=keyptr.gk_data as string;
					if(str==null) str="";

					str=str.Trim('\0');
					str+="|";
					str=str.Replace('\0', '|');

					shorts.Add((ushort)key);
					shorts.Add((ushort)GTIFF_ASCIIPARAMS);
					shorts.Add((ushort)str.Length);
					shorts.Add((ushort)strings.Length);
					strings+=str;

					continue;
				}

				if(keyptr.gk_type==tagtype_t.TYPE_DOUBLE)
				{
					double[] dbl=keyptr.gk_data as double[];
					if(dbl==null)
					{
						shorts.Add((ushort)key);
						shorts.Add((ushort)GTIFF_DOUBLEPARAMS);
						shorts.Add((ushort)0);
						shorts.Add((ushort)0);
					}
					else
					{
						shorts.Add((ushort)key);
						shorts.Add((ushort)GTIFF_DOUBLEPARAMS);
						shorts.Add((ushort)dbl.Length);
						shorts.Add((ushort)doubles.Count);
						doubles.AddRange(dbl);
					}
					continue;
				}

				ushort[] sht=keyptr.gk_data as ushort[];
				if(sht==null)
				{
					shorts.Add((ushort)key);
					shorts.Add((ushort)GTIFF_LOCAL);
					shorts.Add((ushort)0);
					shorts.Add((ushort)0);
				}
				else
				{
					if(sht.Length<2)
					{
						shorts.Add((ushort)key);
						shorts.Add((ushort)GTIFF_LOCAL);
						shorts.Add((ushort)sht.Length);
						if(sht.Length==1) shorts.Add(sht[0]);
						else shorts.Add(0);
					}
					else
					{
						shorts.Add((ushort)key);
						shorts.Add((ushort)GTIFF_GEOKEYDIRECTORY);
						shorts.Add((ushort)sht.Length);
						shorts.Add((ushort)(shortOffset+shortsValues.Count));
						shortsValues.AddRange(sht);
					}
				}
			}

			if(shorts.Count!=shortOffset) return false;
			shorts.AddRange(shortsValues);

			// Write out the Key Directory
			gt.gt_methods.set(gt.gt_tif, (ushort)GTIFF_GEOKEYDIRECTORY, shorts.Count, shorts.ToArray());

			// Write out the params directories
			if(doubles.Count>0) gt.gt_methods.set(gt.gt_tif, (ushort)GTIFF_DOUBLEPARAMS, doubles.Count, doubles.ToArray());
			if(strings.Length>0) gt.gt_methods.set(gt.gt_tif, (ushort)GTIFF_ASCIIPARAMS, strings.Length, strings);

			gt.gt_flags&=~gtiff_flags.FLAG_FILE_MODIFIED;

			return true;
		}
コード例 #27
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, rastertype_t val)
		{
			ushort[] val1=new ushort[] { (ushort)val };
			return GTIFKeySet(gtif, keyID, val1);
		}
コード例 #28
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, coordtrans_t val)
		{
			ushort[] val1=new ushort[] { (ushort)val };
			return GTIFKeySet(gtif, keyID, val1);
		}
コード例 #29
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, projection_t val)
		{
			ushort[] val1=new ushort[] { (ushort)val };
			return GTIFKeySet(gtif, keyID, val1);
		}
コード例 #30
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		// This function writes a geokey_t value to a GeoTIFF file.
		//
		// @param gtif The geotiff information handle from GTIFNew().
		//
		// @param keyID The geokey_t name (such as ProjectedCSTypeGeoKey).
		// This must come from the list of legal geokey_t values
		// (an enumeration) listed below.
		//
		// Note that key values aren't actually flushed to the file until
		// GTIFWriteKeys() is called. Till then
		// the new values are just kept with the GTIF structure.
		//
		// Example:
		//
		//	GTIFKeySet(gtif, GTRasterTypeGeoKey, RasterPixelIsArea);
		//	GTIFKeySet(gtif, GTCitationGeoKey, "UTM 11 North / NAD27");
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, geodeticdatum_t val)
		{
			ushort[] val1=new ushort[] { (ushort)val };
			return GTIFKeySet(gtif, keyID, val1);
		}
コード例 #31
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
 public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, rastertype_t val)
 {
     ushort[] val1 = new ushort[] { (ushort)val };
     return(GTIFKeySet(gtif, keyID, val1));
 }
コード例 #32
0
 public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out coordtrans_t val, int index)
 {
     return(GTIFKeyGet(gtif, thekey, out val, index, 0));
 }
コード例 #33
0
		static int ReadKey(GTIF gt, GTIFReadMethod scan, object aux)
		{
			string message=scan(aux);
			if(message==null) return -1;
			if(message.Length>=12) if(message.ToLower().Substring(0, 12)==FMT_KEYEND.ToLower().Substring(0, 12)) return 0;

			try
			{
				int firstp=message.IndexOfAny(new char[] { '(', ' ', '\t' });
				if(firstp<0) return StringError(message);

				string name=message.Substring(0, firstp).Trim();
				string message1=message.Substring(firstp);

				int colon=message1.IndexOf(':');
				if(colon<0) return StringError(message1);

				string head=message1.Substring(0, colon);
				head=head.Trim(' ', '\t', '(', ')');

				string[] spl=head.Split(',');
				if(spl.Length!=2) return StringError(head);

				string type=spl[0];
				int count=int.Parse(spl[1]);

				// skip white space
				string data=message1.Substring(colon+1).Trim();
				if(data.Length==0) return StringError(message);

				if(GTIFKeyCode(name)<0) return StringError(name);
				geokey_t key=(geokey_t)GTIFKeyCode(name);

				if(GTIFTypeCode(type)<0) return StringError(type);
				tagtype_t ktype=(tagtype_t)GTIFTypeCode(type);

				switch(ktype)
				{
					case tagtype_t.TYPE_ASCII:
						{
							string cdata="";

							int firstDoubleQuote=data.IndexOf('"');
							if(firstDoubleQuote<0) return StringError(data);

							data=data.Substring(firstDoubleQuote+1);

							bool wasesc=false;
							char c='\0';
							for(int i=0; i<data.Length; i++)
							{
								c=data[i];
								if(wasesc)
								{
									if(c=='\\') cdata+='\\';
									else if(c=='"') cdata+='"';
									else if(c=='n') cdata+='\n';
									else if(c=='t') cdata+='\t';
									else if(c=='b') cdata+='\b';
									else if(c=='r') cdata+='\r';
									else if(c=='0') cdata+='\0';

									wasesc=false;
									continue;
								}

								if(c=='\\')
								{
									wasesc=true;
									continue;
								}

								if(c=='\0') break;
								if(c=='"') break;

								cdata+=c;

								if(cdata.Length==count)
								{
									c=data[i+1];
									break;
								}
							}

							if(cdata.Length<count) return StringError(message);
							if(c!='"') return StringError(message);

							GTIFKeySet(gt, key, cdata);
						}
						break;
					case tagtype_t.TYPE_DOUBLE:
						{
							double[] dptr=new double[count];
							int i=0;
							for(; count>0; count-=3)
							{
								spl=data.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
								if(spl.Length!=Math.Min(3, count)) return StringError(data);

								foreach(string part in spl)
								{
									message=part;
									dptr[i++]=GTIFAtof(part);
								}

								if(count>3) message=data=scan(aux);
							}
							GTIFKeySet(gt, key, dptr);
						}
						break;
					case tagtype_t.TYPE_SHORT:
						if(count==1)
						{
							int icode=GTIFValueCode(key, data);
							if(icode<0) return StringError(data);
							ushort code=(ushort)icode;
							GTIFKeySet(gt, key, code);
						}
						else // multi-valued short - no such thing yet
						{
							ushort[] sptr=new ushort[count];
							int i=0;
							for(; count>0; count-=3)
							{
								spl=data.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
								if(spl.Length!=Math.Min(3, count)) return StringError(data);

								foreach(string part in spl)
								{
									message=part;
									sptr[i++]=ushort.Parse(part);
								}

								if(count>3) message=data=scan(aux);
							}
							GTIFKeySet(gt, key, sptr);
						}
						break;
					default: return -1;
				}
			}
			catch
			{
				return StringError(message);
			}
			return 1;
		}
コード例 #34
0
 public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out rastertype_t val, int index)
 {
     return(GTIFKeyGet(gtif, thekey, out val, index, 0));
 }
コード例 #35
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, double val)
		{
			double[] val1=new double[] { val };
			return GTIFKeySet(gtif, keyID, val1);
		}
コード例 #36
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out string val, int index, int count)
		{
			val=null;
			if(count<0) return 0;

			if(!gtif.gt_keys.ContainsKey(thekey)) return 0;
			GeoKey key=gtif.gt_keys[thekey];

			if(key.gk_type!=tagtype_t.TYPE_ASCII) return 0;

			string val_=(string)key.gk_data;
			if(count==0||(count+index)>val_.Length) val=val_.Substring(index);
			else val=val_.Substring(index, count);

			return val.Length;
		}
コード例 #37
0
        static int ReadKey(GTIF gt, GTIFReadMethod scan, object aux)
        {
            string message = scan(aux);

            if (message == null)
            {
                return(-1);
            }
            if (message.Length >= 12)
            {
                if (message.ToLower().Substring(0, 12) == FMT_KEYEND.ToLower().Substring(0, 12))
                {
                    return(0);
                }
            }

            try
            {
                int firstp = message.IndexOfAny(new char[] { '(', ' ', '\t' });
                if (firstp < 0)
                {
                    return(StringError(message));
                }

                string name     = message.Substring(0, firstp).Trim();
                string message1 = message.Substring(firstp);

                int colon = message1.IndexOf(':');
                if (colon < 0)
                {
                    return(StringError(message1));
                }

                string head = message1.Substring(0, colon);
                head = head.Trim(' ', '\t', '(', ')');

                string[] spl = head.Split(',');
                if (spl.Length != 2)
                {
                    return(StringError(head));
                }

                string type  = spl[0];
                int    count = int.Parse(spl[1]);

                // skip white space
                string data = message1.Substring(colon + 1).Trim();
                if (data.Length == 0)
                {
                    return(StringError(message));
                }

                if (GTIFKeyCode(name) < 0)
                {
                    return(StringError(name));
                }
                geokey_t key = (geokey_t)GTIFKeyCode(name);

                if (GTIFTypeCode(type) < 0)
                {
                    return(StringError(type));
                }
                tagtype_t ktype = (tagtype_t)GTIFTypeCode(type);

                switch (ktype)
                {
                case tagtype_t.TYPE_ASCII:
                {
                    string cdata = "";

                    int firstDoubleQuote = data.IndexOf('"');
                    if (firstDoubleQuote < 0)
                    {
                        return(StringError(data));
                    }

                    data = data.Substring(firstDoubleQuote + 1);

                    bool wasesc = false;
                    char c      = '\0';
                    for (int i = 0; i < data.Length; i++)
                    {
                        c = data[i];
                        if (wasesc)
                        {
                            if (c == '\\')
                            {
                                cdata += '\\';
                            }
                            else if (c == '"')
                            {
                                cdata += '"';
                            }
                            else if (c == 'n')
                            {
                                cdata += '\n';
                            }
                            else if (c == 't')
                            {
                                cdata += '\t';
                            }
                            else if (c == 'b')
                            {
                                cdata += '\b';
                            }
                            else if (c == 'r')
                            {
                                cdata += '\r';
                            }
                            else if (c == '0')
                            {
                                cdata += '\0';
                            }

                            wasesc = false;
                            continue;
                        }

                        if (c == '\\')
                        {
                            wasesc = true;
                            continue;
                        }

                        if (c == '\0')
                        {
                            break;
                        }
                        if (c == '"')
                        {
                            break;
                        }

                        cdata += c;

                        if (cdata.Length == count)
                        {
                            c = data[i + 1];
                            break;
                        }
                    }

                    if (cdata.Length < count)
                    {
                        return(StringError(message));
                    }
                    if (c != '"')
                    {
                        return(StringError(message));
                    }

                    GTIFKeySet(gt, key, cdata);
                }
                break;

                case tagtype_t.TYPE_DOUBLE:
                {
                    double[] dptr = new double[count];
                    int      i    = 0;
                    for (; count > 0; count -= 3)
                    {
                        spl = data.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                        if (spl.Length != Math.Min(3, count))
                        {
                            return(StringError(data));
                        }

                        foreach (string part in spl)
                        {
                            message   = part;
                            dptr[i++] = GTIFAtof(part);
                        }

                        if (count > 3)
                        {
                            message = data = scan(aux);
                        }
                    }
                    GTIFKeySet(gt, key, dptr);
                }
                break;

                case tagtype_t.TYPE_SHORT:
                    if (count == 1)
                    {
                        int icode = GTIFValueCode(key, data);
                        if (icode < 0)
                        {
                            return(StringError(data));
                        }
                        ushort code = (ushort)icode;
                        GTIFKeySet(gt, key, code);
                    }
                    else                             // multi-valued short - no such thing yet
                    {
                        ushort[] sptr = new ushort[count];
                        int      i    = 0;
                        for (; count > 0; count -= 3)
                        {
                            spl = data.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                            if (spl.Length != Math.Min(3, count))
                            {
                                return(StringError(data));
                            }

                            foreach (string part in spl)
                            {
                                message   = part;
                                sptr[i++] = ushort.Parse(part);
                            }

                            if (count > 3)
                            {
                                message = data = scan(aux);
                            }
                        }
                        GTIFKeySet(gt, key, sptr);
                    }
                    break;

                default: return(-1);
                }
            }
            catch
            {
                return(StringError(message));
            }
            return(1);
        }
コード例 #38
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out string val)
		{
			val=null;
			if(!gtif.gt_keys.ContainsKey(thekey)) return 0;
			GeoKey key=gtif.gt_keys[thekey];

			if(key.gk_type!=tagtype_t.TYPE_ASCII) return 0;

			val=(string)key.gk_data;

			return val.Length;
		}
コード例 #39
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out double val, int index, int count)
		{
			// ignore count
			val=0;
			double[] vals;
			if(GTIFKeyGet(gtif, thekey, out vals, index, 1)==0) return 0;
			val=vals[0];
			return 1;
		}
コード例 #40
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out double[] val, int index, int count)
		{
			val=null;
			if(!gtif.gt_keys.ContainsKey(thekey)) return 0;
			GeoKey key=gtif.gt_keys[thekey];

			if(key.gk_type!=tagtype_t.TYPE_DOUBLE) return 0;

			double[] val_=(double[])key.gk_data;
			if(count==0||(count+index)>val_.Length) count=val_.Length-index;
			if(count<=0) return 0;
			val=new double[count];
			Array.Copy(val_, index, val, 0, count);
			return count;
		}
コード例 #41
0
ファイル: geo_trans.cs プロジェクト: plynkus/libgeotiff.net
        //***********************************************************************/
        //*								GTIFImageToPCS()						*/
        //***********************************************************************/

        // Translate a pixel/line coordinate to projection coordinates.
        //
        // At this time this function does not support image to PCS translations for
        // tiepoints-only definitions, only pixelscale and transformation matrix
        // formulations.
        //
        // @param gtif The handle from GTIFNew() indicating the target file.
        // @param x A reference to the double containing the pixel offset on input,
        // and into which the easting/longitude will be put on completion.
        // @param y A reference to the double containing the line offset on input,
        // and into which the northing/latitude will be put on completion.
        //
        // @return true if the transformation succeeds, or false if it fails. It may
        // fail if the file doesn't have properly setup transformation information,
        // or it is in a form unsupported by this function.
        public static bool GTIFImageToPCS(GTIF gtif, ref double x, ref double y)
        {
            bool res = false;
            int  tiepoint_count, count, transform_count;
            TIFF tif = gtif.gt_tif;

            double[] tiepoints   = null;
            double[] pixel_scale = null;
            double[] transform   = null;

            // --------------------------------------------------------------------
            //		Fetch tiepoints and pixel scale.
            // --------------------------------------------------------------------
            object ap;

            if (!gtif.gt_methods.get(tif, (ushort)GTIFF_TIEPOINTS, out tiepoint_count, out ap))
            {
                tiepoint_count = 0;
            }
            else if (ap is double[])
            {
                tiepoints = (double[])ap;
            }

            if (!gtif.gt_methods.get(tif, (ushort)GTIFF_PIXELSCALE, out count, out ap))
            {
                count = 0;
            }
            else if (ap is double[])
            {
                pixel_scale = (double[])ap;
            }

            if (!gtif.gt_methods.get(tif, (ushort)GTIFF_TRANSMATRIX, out transform_count, out ap))
            {
                transform_count = 0;
            }
            else if (ap is double[])
            {
                transform = (double[])ap;
            }

            // --------------------------------------------------------------------
            //		If we have a transformation matrix, use it.
            // --------------------------------------------------------------------
            if (transform_count == 16)
            {
                double x_in = x, y_in = y;

                x = x_in * transform[0] + y_in * transform[1] + transform[3];
                y = x_in * transform[4] + y_in * transform[5] + transform[7];

                res = true;
            }
            // --------------------------------------------------------------------
            //		If the pixelscale count is zero, but we have tiepoints use
            //		the tiepoint based approach.
            // --------------------------------------------------------------------
            else if (tiepoint_count > 6 && count == 0)
            {
                res = GTIFTiepointTranslate(tiepoint_count / 6, tiepoints, 0, tiepoints, 3, ref x, ref y);
            }
            // --------------------------------------------------------------------
            //		For now we require one tie point, and a valid pixel scale.
            // --------------------------------------------------------------------
            else if (count >= 3 && tiepoint_count >= 6)
            {
                x = (x - tiepoints[0]) * pixel_scale[0] + tiepoints[3];
                y = (y - tiepoints[1]) * (-1 * pixel_scale[1]) + tiepoints[4];

                res = true;
            }

            return(res);
        }
コード例 #42
0
 public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out double val, int index)
 {
     return(GTIFKeyGet(gtif, thekey, out val, index, 0));
 }
コード例 #43
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
 public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, ushort val)
 {
     ushort[] val1 = new ushort[] { val };
     return(GTIFKeySet(gtif, keyID, val1));
 }
コード例 #44
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
 public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, projection_t val)
 {
     ushort[] val1 = new ushort[] { (ushort)val };
     return(GTIFKeySet(gtif, keyID, val1));
 }
コード例 #45
0
		//**********************************************************************
		//						GTIFFetchProjParms()
		//
		//		Fetch the projection parameters for a particular projection
		//		from a GeoTIFF file, and fill the GTIFDefn structure out
		//		with them.
		//**********************************************************************
		static void GTIFFetchProjParms(GTIF gtif, GTIFDefn defn)
		{
			double NatOriginLong=0.0, NatOriginLat=0.0, RectGridAngle=0.0;
			double FalseEasting=0.0, FalseNorthing=0.0, NatOriginScale=1.0;
			double StdParallel1=0.0, StdParallel2=0.0, Azimuth=0.0;

			// --------------------------------------------------------------------
			//		Get the false easting, and northing if available.
			// --------------------------------------------------------------------
			if(GTIFKeyGet(gtif, geokey_t.ProjFalseEastingGeoKey, out FalseEasting, 0, 1)==0&&
				GTIFKeyGet(gtif, geokey_t.ProjCenterEastingGeoKey, out FalseEasting, 0, 1)==0&&
				GTIFKeyGet(gtif, geokey_t.ProjFalseOriginEastingGeoKey, out FalseEasting, 0, 1)==0) FalseEasting=0.0;

			if(GTIFKeyGet(gtif, geokey_t.ProjFalseNorthingGeoKey, out FalseNorthing, 0, 1)==0&&
				GTIFKeyGet(gtif, geokey_t.ProjCenterNorthingGeoKey, out FalseNorthing, 0, 1)==0&&
				GTIFKeyGet(gtif, geokey_t.ProjFalseOriginNorthingGeoKey, out FalseNorthing, 0, 1)==0) FalseNorthing=0.0;

			switch(defn.CTProjection)
			{
				case coordtrans_t.CT_Stereographic:
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, out NatOriginScale, 0, 1)==0) NatOriginScale=1.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjCenterLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjCenterLongGeoKey;
					defn.ProjParm[4]=NatOriginScale;
					defn.ProjParmId[4]=geokey_t.ProjScaleAtNatOriginGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_LambertConfConic_1SP:
				case coordtrans_t.CT_Mercator:
				case coordtrans_t.CT_ObliqueStereographic:
				case coordtrans_t.CT_TransverseMercator:
				case coordtrans_t.CT_TransvMercator_SouthOriented:
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, out NatOriginScale, 0, 1)==0) NatOriginScale=1.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjNatOriginLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjNatOriginLongGeoKey;
					defn.ProjParm[4]=NatOriginScale;
					defn.ProjParmId[4]=geokey_t.ProjScaleAtNatOriginGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_ObliqueMercator: // hotine
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjAzimuthAngleGeoKey, out Azimuth, 0, 1)==0) Azimuth=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjRectifiedGridAngleGeoKey, out RectGridAngle, 0, 1)==0) RectGridAngle=90.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, out NatOriginScale, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjScaleAtCenterGeoKey, out NatOriginScale, 0, 1)==0) NatOriginScale=1.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjCenterLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjCenterLongGeoKey;
					defn.ProjParm[2]=Azimuth;
					defn.ProjParmId[2]=geokey_t.ProjAzimuthAngleGeoKey;
					defn.ProjParm[3]=RectGridAngle;
					defn.ProjParmId[3]=geokey_t.ProjRectifiedGridAngleGeoKey;
					defn.ProjParm[4]=NatOriginScale;
					defn.ProjParmId[4]=geokey_t.ProjScaleAtCenterGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_CassiniSoldner:
				case coordtrans_t.CT_Polyconic:
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, out NatOriginScale, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjScaleAtCenterGeoKey, out NatOriginScale, 0, 1)==0) NatOriginScale=1.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjNatOriginLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjNatOriginLongGeoKey;
					defn.ProjParm[4]=NatOriginScale;
					defn.ProjParmId[4]=geokey_t.ProjScaleAtNatOriginGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_AzimuthalEquidistant:
				case coordtrans_t.CT_MillerCylindrical:
				case coordtrans_t.CT_Gnomonic:
				case coordtrans_t.CT_LambertAzimEqualArea:
				case coordtrans_t.CT_Orthographic:
				case coordtrans_t.CT_NewZealandMapGrid:
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjCenterLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjCenterLongGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_Equirectangular:
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjStdParallel1GeoKey, out StdParallel1, 0, 1)==0) StdParallel1=0.0;

					// notdef: should transform to decimal degrees at this point

					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjCenterLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjCenterLongGeoKey;
					defn.ProjParm[2]=StdParallel1;
					defn.ProjParmId[2]=geokey_t.ProjStdParallel1GeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_Robinson:
				case coordtrans_t.CT_Sinusoidal:
				case coordtrans_t.CT_VanDerGrinten:
					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjCenterLongGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_PolarStereographic:
					if(GTIFKeyGet(gtif, geokey_t.ProjStraightVertPoleLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjScaleAtNatOriginGeoKey, out NatOriginScale, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjScaleAtCenterGeoKey, out NatOriginScale, 0, 1)==0) NatOriginScale=1.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjNatOriginLatGeoKey; ;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjStraightVertPoleLongGeoKey;
					defn.ProjParm[4]=NatOriginScale;
					defn.ProjParmId[4]=geokey_t.ProjScaleAtNatOriginGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_LambertConfConic_2SP:
					if(GTIFKeyGet(gtif, geokey_t.ProjStdParallel1GeoKey, out StdParallel1, 0, 1)==0) StdParallel1=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjStdParallel2GeoKey, out StdParallel2, 0, 1)==0) StdParallel1=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=NatOriginLat;
					defn.ProjParmId[0]=geokey_t.ProjFalseOriginLatGeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjFalseOriginLongGeoKey;
					defn.ProjParm[2]=StdParallel1;
					defn.ProjParmId[2]=geokey_t.ProjStdParallel1GeoKey;
					defn.ProjParm[3]=StdParallel2;
					defn.ProjParmId[3]=geokey_t.ProjStdParallel2GeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_AlbersEqualArea:
				case coordtrans_t.CT_EquidistantConic:
					if(GTIFKeyGet(gtif, geokey_t.ProjStdParallel1GeoKey, out StdParallel1, 0, 1)==0) StdParallel1=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjStdParallel2GeoKey, out StdParallel2, 0, 1)==0) StdParallel2=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLatGeoKey, out NatOriginLat, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLatGeoKey, out NatOriginLat, 0, 1)==0) NatOriginLat=0.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=StdParallel1;
					defn.ProjParmId[0]=geokey_t.ProjStdParallel1GeoKey;
					defn.ProjParm[1]=StdParallel2;
					defn.ProjParmId[1]=geokey_t.ProjStdParallel2GeoKey;
					defn.ProjParm[2]=NatOriginLat;
					defn.ProjParmId[2]=geokey_t.ProjNatOriginLatGeoKey;
					defn.ProjParm[3]=NatOriginLong;
					defn.ProjParmId[3]=geokey_t.ProjNatOriginLongGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;

				case coordtrans_t.CT_CylindricalEqualArea:
					if(GTIFKeyGet(gtif, geokey_t.ProjStdParallel1GeoKey, out StdParallel1, 0, 1)==0) StdParallel1=0.0;

					if(GTIFKeyGet(gtif, geokey_t.ProjNatOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjFalseOriginLongGeoKey, out NatOriginLong, 0, 1)==0&&
						GTIFKeyGet(gtif, geokey_t.ProjCenterLongGeoKey, out NatOriginLong, 0, 1)==0) NatOriginLong=0.0;

					// notdef: should transform to decimal degrees at this point
					defn.ProjParm[0]=StdParallel1;
					defn.ProjParmId[0]=geokey_t.ProjStdParallel1GeoKey;
					defn.ProjParm[1]=NatOriginLong;
					defn.ProjParmId[1]=geokey_t.ProjNatOriginLongGeoKey;
					defn.ProjParm[5]=FalseEasting;
					defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
					defn.ProjParm[6]=FalseNorthing;
					defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

					defn.nParms=7;
					break;
			}

			// --------------------------------------------------------------------
			//		Normalize any linear parameters into meters. In GeoTIFF
			//		the linear projection parameter tags are normally in the
			//		units of the coordinate system described.
			// --------------------------------------------------------------------
			for(int iParm=0; iParm<defn.nParms; iParm++)
			{
				switch(defn.ProjParmId[iParm])
				{
					case geokey_t.ProjFalseEastingGeoKey:
					case geokey_t.ProjFalseNorthingGeoKey:
					case geokey_t.ProjFalseOriginEastingGeoKey:
					case geokey_t.ProjFalseOriginNorthingGeoKey:
					case geokey_t.ProjCenterEastingGeoKey:
					case geokey_t.ProjCenterNorthingGeoKey:
						if(defn.UOMLengthInMeters!=0&&defn.UOMLengthInMeters!=1.0) defn.ProjParm[iParm]*=defn.UOMLengthInMeters;
						break;
				}
			}
		}
コード例 #46
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, string val)
		{
			if(val==null) // delete the indicated tag
			{
				if(!gtif.gt_keys.ContainsKey(keyID)) return false;
				gtif.gt_keys.Remove(keyID);
				gtif.gt_flags|=gtiff_flags.FLAG_FILE_MODIFIED;
				return true;
			}

			if(gtif.gt_keys.ContainsKey(keyID))
			{
				gtif.gt_keys.Remove(keyID);
				gtif.gt_flags|=gtiff_flags.FLAG_FILE_MODIFIED;
			}

			val=val.Trim('\0');

			// We need to create the key
			try
			{
				GeoKey key=new GeoKey();
				key.gk_key=keyID;
				key.gk_type=tagtype_t.TYPE_ASCII;
				key.gk_count=val.Length;
				key.gk_data=val.Substring(0, val.Length);
				gtif.gt_keys.Add(keyID, key);
				gtif.gt_flags|=gtiff_flags.FLAG_FILE_MODIFIED;
				return true;
			}
			catch
			{
				return false;
			}
		}
コード例 #47
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
 // This function writes a geokey_t value to a GeoTIFF file.
 //
 // @param gtif The geotiff information handle from GTIFNew().
 //
 // @param keyID The geokey_t name (such as ProjectedCSTypeGeoKey).
 // This must come from the list of legal geokey_t values
 // (an enumeration) listed below.
 //
 // Note that key values aren't actually flushed to the file until
 // GTIFWriteKeys() is called. Till then
 // the new values are just kept with the GTIF structure.
 //
 // Example:
 //
 //	GTIFKeySet(gtif, GTRasterTypeGeoKey, RasterPixelIsArea);
 //	GTIFKeySet(gtif, GTCitationGeoKey, "UTM 11 North / NAD27");
 public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, geodeticdatum_t val)
 {
     ushort[] val1 = new ushort[] { (ushort)val };
     return(GTIFKeySet(gtif, keyID, val1));
 }
コード例 #48
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out rastertype_t val, int index)
		{
			return GTIFKeyGet(gtif, thekey, out val, index, 0);
		}
コード例 #49
0
ファイル: geo_set.cs プロジェクト: plynkus/libgeotiff.net
 public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, coordtrans_t val)
 {
     ushort[] val1 = new ushort[] { (ushort)val };
     return(GTIFKeySet(gtif, keyID, val1));
 }
コード例 #50
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out double val, int index)
		{
			return GTIFKeyGet(gtif, thekey, out val, index, 0);
		}
コード例 #51
0
		// Importing metadata file

		// Import the directory info, using whatever method is specified
		// (defaults to fscanf if null). The "aux" parameter is provided for user
		// defined method for passing file or whatever.
		//
		// The input format is a "GeoTIFF meta-data" file, which may be
		// generated by the GTIFFPrint() routine.
		public static bool GTIFImport(GTIF gtif)
		{
			return GTIFImport(gtif, null, null);
		}
コード例 #52
0
ファイル: geo_new.cs プロジェクト: plynkus/libgeotiff.net
        // **************************************************************************
        // *						GTIFNewWithMethods()							*
        // *																		*
        // *	Create a new geotiff, passing in the methods structure to			*
        // *	support not libtiff implementations without replacing the			*
        // *	default methods.													*
        // **************************************************************************
        public static GTIF GTIFNewWithMethods(TIFF tif, TIFFMethod methods)
        {
            GTIF gt = null;

            try
            {
                gt            = new GTIF();
                gt.gt_methods = new TIFFMethod();
                gt.gt_keys    = new Dictionary <geokey_t, GeoKey>();
            }
            catch
            {
                return(null);
            }

            // install TIFF file and I/O methods
            gt.gt_tif          = tif;
            gt.gt_methods.get  = methods.get;
            gt.gt_methods.set  = methods.set;
            gt.gt_methods.type = methods.type;

            gt.gt_rev_major = GvCurrentRevision;
            gt.gt_rev_minor = GvCurrentMinorRev;
            gt.gt_version   = GvCurrentVersion;

            if (tif == null)
            {
                return(gt);
            }

            object data;
            int    nshorts;

            // since this is an array, GTIF will allocate the memory
            if (!gt.gt_methods.get(tif, (ushort)GTIFF_GEOKEYDIRECTORY, out nshorts, out data))
            {
                return(gt);
            }

            if (nshorts < 4)
            {
                return(null);
            }
            ushort[] shorts = data as ushort[];
            if (shorts == null || shorts.Length < 4)
            {
                return(null);
            }

            if (shorts[0] > GvCurrentVersion)
            {
                return(null);
            }
            gt.gt_version = shorts[0];

            if (shorts[1] > GvCurrentRevision)
            {
                // issue warning
            }
            gt.gt_rev_major = shorts[1];
            gt.gt_rev_minor = shorts[2];

            int count = shorts[3];

            if (count == 0)
            {
                return(gt);
            }
            if (shorts.Length < (count * 4 + 4))
            {
                return(null);
            }

            // If we got here, then the geokey can be parsed

            // Get the PARAMS Tags, if any
            int ndoubles;

            double[] doubles;
            if (!gt.gt_methods.get(tif, (ushort)GTIFF_DOUBLEPARAMS, out ndoubles, out data))
            {
                try
                {
                    doubles = new double[MAX_VALUES];
                }
                catch
                {
                    return(null);
                }
            }
            else
            {
                doubles = data as double[];
                if (doubles == null)
                {
                    return(null);
                }
            }

            int    stringsLength = 0;
            string strings       = null;

            if (gt.gt_methods.get(tif, (ushort)GTIFF_ASCIIPARAMS, out stringsLength, out data))
            {
                strings = data as string;
                if (strings == null)
                {
                    return(null);
                }
                strings       = strings.TrimEnd('\0');         // last NULL doesn't count; "|" used for delimiter
                stringsLength = strings.Length;
            }

            for (int i = 0; i < count; i++)
            {
                ushort KeyID           = shorts[i * 4 + 4];
                ushort TIFFTagLocation = shorts[i * 4 + 5];
                ushort Count           = shorts[i * 4 + 6];
                ushort Value_Offset    = shorts[i * 4 + 7];

                GeoKey keyptr;

                try
                {
                    keyptr = new GeoKey();

                    keyptr.gk_key = (geokey_t)KeyID;

                    if (TIFFTagLocation != 0)
                    {
                        keyptr.gk_type = gt.gt_methods.type(gt.gt_tif, TIFFTagLocation);
                    }
                    else
                    {
                        keyptr.gk_type = tagtype_t.TYPE_SHORT;                    //gt.gt_methods.type(gt.gt_tif, (ushort)GTIFF_GEOKEYDIRECTORY);
                    }
                    switch (TIFFTagLocation)
                    {
                    case (ushort)GTIFF_LOCAL:
                        // store value into data value
                        keyptr.gk_data  = new ushort[] { Value_Offset };
                        keyptr.gk_count = 1;
                        break;

                    case (ushort)GTIFF_GEOKEYDIRECTORY:
                        ushort[] s = new ushort[Count];
                        keyptr.gk_data = s;
                        Array.Copy(shorts, Value_Offset, s, 0, Count);
                        keyptr.gk_count = Count;
                        break;

                    case (ushort)GTIFF_DOUBLEPARAMS:
                        double[] d = new double[Count];
                        keyptr.gk_data = d;
                        Array.Copy(doubles, Value_Offset, d, 0, Count);
                        keyptr.gk_count = Count;
                        break;

                    case (ushort)GTIFF_ASCIIPARAMS:
                        string str = strings.Substring(Value_Offset, Count);
                        str             = str.Replace('|', '\0');
                        str             = str.Trim('\0');
                        keyptr.gk_count = str.Length;
                        keyptr.gk_data  = str;
                        break;

                    default:
                        return(null);                                // failure
                    }
                }
                catch
                {
                    return(null);
                }

                gt.gt_keys.Add(keyptr.gk_key, keyptr);
            }

            return(gt);
        }
コード例 #53
0
		static int ReadTag(GTIF gt, GTIFReadMethod scan, object aux)
		{
			string message=scan(aux);
			if(message==null) return -1;
			if(message.Length>=12) if(message.ToLower().Substring(0, 12)==FMT_TAGEND.ToLower().Substring(0, 12)) return 0;

			try
			{
				int firstp=message.IndexOfAny(new char[] { '(', ' ', '\t' });
				if(firstp<0) return StringError(message);

				string tagname=message.Substring(0, firstp).Trim();
				message=message.Substring(firstp);

				int colon=message.IndexOf(':');
				if(colon<0) return StringError(message);

				message=message.Substring(0, colon);
				message=message.Trim(' ', '\t', '(', ')');

				string[] spl=message.Split(',');
				if(spl.Length!=2) return StringError(message);

				int nrows=int.Parse(spl[0]);
				int ncols=int.Parse(spl[1]);

				int tag=GTIFTagCode(tagname);
				if(tag<0) return StringError(tagname);

				int count=nrows*ncols;

				double[] dptr=new double[count];

				for(int i=0; i<nrows; i++)
				{
					message=scan(aux);
					if(message==null) return -1;

					spl=message.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
					if(spl.Length!=ncols) StringError(message);

					for(int j=0; j<ncols; j++)
					{
						message=spl[j];
						dptr[i*ncols+j]=GTIFAtof(message);
					}
				}
				gt.gt_methods.set(gt.gt_tif, (ushort)tag, count, dptr);
			}
			catch
			{
				return StringError(message);
			}

			return 1;
		}
コード例 #54
0
ファイル: geo_free.cs プロジェクト: LogoPhonix/libgeotiff.net
		//*********************************************************************
		//
		//							Public Routines
		//
		//*********************************************************************

		// This function deallocates an existing GeoTIFF access handle previously
		// created with GTIFNew(). If the handle was
		// used to write GeoTIFF keys to the TIFF file, the
		// GTIFWriteKeys() function should be used
		// to flush results to the file before calling GTIFFree(). GTIFFree()
		// should be called before XTIFFClose() is
		// called on the corresponding TIFF file handle.
		public static void GTIFFree(GTIF gtif)
		{
			if(gtif==null) return;
			gtif.gt_keys.Clear();
		}
コード例 #55
0
		// Print off the directory info, using whatever method is specified
		// (defaults to fprintf if null). The "aux" parameter is provided for user
		// defined method for passing parameters or whatever.
		//
		// The output format is a "GeoTIFF meta-data" file, which may be
		// used to import information with the GTIFFImport() routine.
		public static void GTIFPrint(GTIF gtif)
		{
			GTIFPrint(gtif, null, null);
		}
コード例 #56
0
        // Importing metadata file

        // Import the directory info, using whatever method is specified
        // (defaults to fscanf if null). The "aux" parameter is provided for user
        // defined method for passing file or whatever.
        //
        // The input format is a "GeoTIFF meta-data" file, which may be
        // generated by the GTIFFPrint() routine.
        public static bool GTIFImport(GTIF gtif)
        {
            return(GTIFImport(gtif, null, null));
        }
コード例 #57
0
        public static bool GTIFImport(GTIF gtif, GTIFReadMethod scan, object aux)
        {
            if (scan == null)
            {
                scan = DefaultRead;
            }
            if (aux == null)
            {
                aux = Console.In;
            }

            string message = scan(aux);

            if (message == null || message.Length < 20)
            {
                return(false);
            }
            if (message.ToLower().Substring(0, 20) != FMT_GEOTIFF.ToLower().Substring(0, 20))
            {
                return(false);
            }

            message = scan(aux);
            if (message == null || message.Length < 10)
            {
                return(false);
            }
            if (message.ToLower().Substring(0, 8) != FMT_VERSION.ToLower().Substring(0, 8))
            {
                return(false);
            }
            message = message.Substring(9);
            try
            {
                gtif.gt_version = ushort.Parse(message);
            }
            catch
            {
                return(false);
            }

            message = scan(aux);
            if (message == null || message.Length < 15)
            {
                return(false);
            }
            if (message.ToLower().Substring(0, 13) != FMT_REV.ToLower().Substring(0, 13))
            {
                return(false);
            }
            message = message.Substring(14);
            try
            {
                string[] spl = message.Split('.');
                if (spl.Length != 2)
                {
                    return(false);
                }
                gtif.gt_rev_major = ushort.Parse(spl[0]);
                gtif.gt_rev_minor = ushort.Parse(spl[1]);
            }
            catch
            {
                return(false);
            }

            message = scan(aux);
            if (message == null || message.Length < 19)
            {
                return(false);
            }
            if (message.ToLower().Substring(0, 19) != FMT_TAGS.ToLower().Substring(0, 19))
            {
                return(false);
            }

            int status;

            while ((status = ReadTag(gtif, scan, aux)) > 0)
            {
                ;
            }
            if (status < 0)
            {
                return(false);
            }

            message = scan(aux);
            if (message == null || message.Length < 18)
            {
                return(false);
            }
            if (message.ToLower().Substring(0, 18) != FMT_KEYS.ToLower().Substring(0, 18))
            {
                return(false);
            }

            while ((status = ReadKey(gtif, scan, aux)) > 0)
            {
                ;
            }
            return(status == 0);            // success
        }
コード例 #58
0
ファイル: geo_set.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static bool GTIFKeySet(GTIF gtif, geokey_t keyID, ushort val)
		{
			ushort[] val1=new ushort[] { val };
			return GTIFKeySet(gtif, keyID, val1);
		}
コード例 #59
0
		//**********************************************************************
		//							GTIFGetDefn()
		//**********************************************************************
		//
		// @param psGTIF GeoTIFF information handle as returned by GTIFNew.
		// @param psDefn Pointer to an existing GTIFDefn structure. This structure
		// does not need to have been pre-initialized at all.
		//
		// @return true if the function has been successful, otherwise false.
		//
		// This function reads the coordinate system definition from a GeoTIFF file,
		// and normalizes it into a set of component information using
		// definitions from CSV (Comma Seperated Value ASCII) files derived from
		// EPSG tables. This function is intended to simplify correct support for
		// reading files with defined PCS (Projected Coordinate System) codes that
		// wouldn't otherwise be directly known by application software by reducing
		// it to the underlying projection method, parameters, datum, ellipsoid,
		// prime meridian and units.
		//
		// The application should pass a pointer to an existing uninitialized
		// GTIFDefn structure, and GTIFGetDefn() will fill it in. The fuction
		// currently always returns TRUE but in the future will return FALSE if
		// CSV files are not found. In any event, all geokeys actually found in the
		// file will be copied into the GTIFDefn. However, if the CSV files aren't
		// found codes implied by other codes will not be set properly.
		//
		// GTIFGetDefn() will not generally work if the EPSG derived CSV files cannot
		// be found. By default a modest attempt will be made to find them, but
		// in general it is necessary for the calling application to override the
		// logic to find them. This can be done by calling the SetCSVFilenameHook()
		// function to override the search method based on application knowledge of
		// where they are found.
		//
		// The normalization methodology operates by fetching tags from the GeoTIFF
		// file, and then setting all other tags implied by them in the structure. The
		// implied relationships are worked out by reading definitions from the 
		// various EPSG derived CSV tables.
		//
		// For instance, if a PCS (ProjectedCSTypeGeoKey) is found in the GeoTIFF file
		// this code is used to lookup a record in the horiz_cs.csv CSV
		// file. For example given the PCS 26746 we can find the name
		// (NAD27 / California zone VI), the GCS 4257 (NAD27), and the ProjectionCode
		// 10406 (California CS27 zone VI). The GCS, and ProjectionCode can in turn
		// be looked up in other tables until all the details of units, ellipsoid,
		// prime meridian, datum, projection (LambertConfConic_2SP) and projection
		// parameters are established. A full listgeo dump of a file
		// for this result might look like the following, all based on a single PCS
		// value:
		//
		//	%listgeo -norm ~/data/geotiff/pci_eg/spaf27.tif
		//	Geotiff_Information:
		//		Version: 1
		//		Key_Revision: 1.0
		//		Tagged_Information:
		//			ModelTiepointTag (2,3):
		//				0			0			0
		//				1577139.71	634349.176	0
		//			ModelPixelScaleTag (1,3):
		//				195.509321	198.32184	0
		//			End_Of_Tags.
		//		Keyed_Information:
		//			GTModelTypeGeoKey (Short,1): ModelTypeProjected
		//			GTRasterTypeGeoKey (Short,1): RasterPixelIsArea
		//			ProjectedCSTypeGeoKey (Short,1): PCS_NAD27_California_VI
		//			End_Of_Keys.
		//		End_Of_Geotiff.
		//
		//	PCS = 26746 (NAD27 / California zone VI)
		//	Projection = 10406 (California CS27 zone VI)
		//	Projection Method: CT_LambertConfConic_2SP
		//		ProjStdParallel1GeoKey: 33.883333
		//		ProjStdParallel2GeoKey: 32.766667
		//		ProjFalseOriginLatGeoKey: 32.166667
		//		ProjFalseOriginLongGeoKey: -116.233333
		//		ProjFalseEastingGeoKey: 609601.219202
		//		ProjFalseNorthingGeoKey: 0.000000
		//	GCS: 4267/NAD27
		//	Datum: 6267/North American Datum 1927
		//	Ellipsoid: 7008/Clarke 1866 (6378206.40,6356583.80)
		//	Prime Meridian: 8901/Greenwich (0.000000)
		//	Projection Linear Units: 9003/US survey foot (0.304801m)
		//
		// Note that GTIFGetDefn() does not inspect or return the tiepoints and scale.
		// This must be handled seperately as it normally would. It is intended to
		// simplify capture and normalization of the coordinate system definition.
		// Note that GTIFGetDefn() also does the following things:
		//
		//	*	Convert all angular values to decimal degrees.
		//	*	Convert all linear values to meters.
		//	*	Return the linear units and conversion to meters for the tiepoints and
		//		scale (though the tiepoints and scale remain in their native units).
		//	*	When reading projection parameters a variety of differences between
		//		different GeoTIFF generators are handled, and a normalized set of
		//		parameters for each projection are always returned.
		//
		// Code fields in the GTIFDefn are filled with KvUserDefined if there is not value to
		// assign. The parameter lists for each of the underlying projection transform methods
		// can be found at the Projections (http://www.remotesensing.org/geotiff/proj_list) page.
		// Note that nParms will be set based on the maximum parameter used. Some of the
		// parameters may not be used in which case the GTIFDefn::ProjParmId[] will be zero.
		// This is done to retain correspondence to the EPSG parameter numbering scheme.
		//
		//The geotiff_proj4.cs module distributed with libgeotiff can be used as an example of
		// code that converts a GTIFDefn into another projection system.
		//
		// @see GTIFKeySet(), SetCSVFilenameHook()
		public static bool GTIFGetDefn(GTIF gtif, GTIFDefn defn)
		{
			// --------------------------------------------------------------------
			//		Initially we default all the information we can.
			// --------------------------------------------------------------------
			defn.DefnSet=true;
			defn.Model=(modeltype_t)KvUserDefined;
			defn.PCS=(pcstype_t)KvUserDefined;
			defn.GCS=(geographic_t)KvUserDefined;
			defn.UOMLength=(geounits_t)KvUserDefined;
			defn.UOMLengthInMeters=1.0;
			defn.UOMAngle=(geounits_t)KvUserDefined;
			defn.UOMAngleInDegrees=1.0;
			defn.Datum=(geodeticdatum_t)KvUserDefined;
			defn.Ellipsoid=(ellipsoid_t)KvUserDefined;
			defn.SemiMajor=0.0;
			defn.SemiMinor=0.0;
			defn.PM=(primemeridian_t)KvUserDefined;
			defn.PMLongToGreenwich=0.0;
			defn.TOWGS84Count=0;
			for(int i=0; i<defn.TOWGS84.Length; i++) defn.TOWGS84[i]=0;

			defn.ProjCode=(projection_t)KvUserDefined;
			defn.Projection=KvUserDefined;
			defn.CTProjection=(coordtrans_t)KvUserDefined;

			defn.nParms=0;
			for(int i=0; i<MAX_GTIF_PROJPARMS; i++)
			{
				defn.ProjParm[i]=0.0;
				defn.ProjParmId[i]=0;
			}

			defn.MapSys=KvUserDefined;
			defn.Zone=0;

			// --------------------------------------------------------------------
			//		Do we have any geokeys?
			// --------------------------------------------------------------------
			int nKeyCount=0;
			int[] anVersion=new int[3];
			GTIFDirectoryInfo(gtif, anVersion, out nKeyCount);

			if(nKeyCount==0)
			{
				defn.DefnSet=false;
				return false;
			}

			// --------------------------------------------------------------------
			//		Try to get the overall model type.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GTModelTypeGeoKey, out defn.Model, 0, 1);

			// --------------------------------------------------------------------
			//		Extract the Geog units.
			// --------------------------------------------------------------------
			geounits_t nGeogUOMLinear=geounits_t.Linear_Meter;
			GTIFKeyGet(gtif, geokey_t.GeogLinearUnitsGeoKey, out nGeogUOMLinear, 0, 1);

			// --------------------------------------------------------------------
			//		Try to get a PCS.
			// --------------------------------------------------------------------
			string dummy;

			if(GTIFKeyGet(gtif, geokey_t.ProjectedCSTypeGeoKey, out defn.PCS, 0, 1)==1
				&&defn.PCS!=(pcstype_t)KvUserDefined) // Translate this into useful information.
				GTIFGetPCSInfo(defn.PCS, out dummy, out defn.ProjCode, out defn.UOMLength, out defn.GCS);

			// --------------------------------------------------------------------
			//		If we have the PCS code, but didn't find it in the CSV files
			//		(likely because we can't find them) we will try some "jiffy
			//		rules" for UTM and state plane.
			// --------------------------------------------------------------------
			if(defn.PCS!=(pcstype_t)KvUserDefined&&defn.ProjCode==(projection_t)KvUserDefined)
			{
				int mapSys, zone;
				geographic_t GCS=defn.GCS;

				mapSys=GTIFPCSToMapSys(defn.PCS, out GCS, out zone);
				if(mapSys!=KvUserDefined)
				{
					defn.ProjCode=GTIFMapSysToProj(mapSys, zone);
					defn.GCS=GCS;
				}
			}

			// --------------------------------------------------------------------
			//		If the Proj_ code is specified directly, use that.
			// --------------------------------------------------------------------
			if(defn.ProjCode==(projection_t)KvUserDefined)
				GTIFKeyGet(gtif, geokey_t.ProjectionGeoKey, out defn.ProjCode, 0, 1);

			if(defn.ProjCode!=(projection_t)KvUserDefined)
			{
				// We have an underlying projection transformation value. Look
				// this up. For a PCS of "WGS 84 / UTM 11" the transformation
				// would be Transverse Mercator, with a particular set of options.
				// The nProjTRFCode itself would correspond to the name
				// "UTM zone 11N", and doesn't include datum info.

				GTIFGetProjTRFInfo(defn.ProjCode, out dummy, out defn.Projection, defn.ProjParm);

				// Set the GeoTIFF identity of the parameters.
				defn.CTProjection=EPSGProjMethodToCTProjMethod(defn.Projection);

				SetGTParmIds(defn.CTProjection, defn.ProjParmId, null);
				defn.nParms=7;
			}

			// --------------------------------------------------------------------
			//		Try to get a GCS. If found, it will override any implied by
			//		the PCS.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GeographicTypeGeoKey, out defn.GCS, 0, 1);
			if(defn.GCS<(geographic_t)1||defn.GCS>=(geographic_t)KvUserDefined)
				defn.GCS=(geographic_t)KvUserDefined;

			// --------------------------------------------------------------------
			//		Derive the datum, and prime meridian from the GCS.
			// --------------------------------------------------------------------
			if(defn.GCS!=(geographic_t)KvUserDefined)
				GTIFGetGCSInfo(defn.GCS, out dummy, out defn.Datum, out defn.PM, out defn.UOMAngle);

			// --------------------------------------------------------------------
			//		Handle the GCS angular units. GeogAngularUnitsGeoKey
			//		overrides the GCS or PCS setting.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GeogAngularUnitsGeoKey, out defn.UOMAngle, 0, 1);
			if(defn.UOMAngle!=(geounits_t)KvUserDefined)
				GTIFGetUOMAngleInfo(defn.UOMAngle, out dummy, out defn.UOMAngleInDegrees);

			// --------------------------------------------------------------------
			//		Check for a datum setting, and then use the datum to derive
			//		an ellipsoid.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GeogGeodeticDatumGeoKey, out defn.Datum, 0, 1);
			if(defn.Datum!=(geodeticdatum_t)KvUserDefined)
				GTIFGetDatumInfo(defn.Datum, out dummy, out defn.Ellipsoid);

			// --------------------------------------------------------------------
			//		Check for an explicit ellipsoid. Use the ellipsoid to
			//		derive the ellipsoid characteristics, if possible.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GeogEllipsoidGeoKey, out defn.Ellipsoid, 0, 1);
			if(defn.Ellipsoid!=(ellipsoid_t)KvUserDefined)
				GTIFGetEllipsoidInfo(defn.Ellipsoid, out dummy, out defn.SemiMajor, out defn.SemiMinor);

			// --------------------------------------------------------------------
			//		Check for overridden ellipsoid parameters. It would be nice
			//		to warn if they conflict with provided information, but for
			//		now we just override.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GeogSemiMajorAxisGeoKey, out defn.SemiMajor, 0, 1);
			GTIFKeyGet(gtif, geokey_t.GeogSemiMinorAxisGeoKey, out defn.SemiMinor, 0, 1);

			double invFlattening;
			if(GTIFKeyGet(gtif, geokey_t.GeogInvFlatteningGeoKey, out invFlattening, 0, 1)==1)
			{
				if(invFlattening!=0.0) defn.SemiMinor=defn.SemiMajor*(1-1.0/invFlattening);
				else defn.SemiMinor=defn.SemiMajor;
			}

			// --------------------------------------------------------------------
			//		Get the prime meridian info.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.GeogPrimeMeridianGeoKey, out defn.PM, 0, 1);

			if(defn.PM!=(primemeridian_t)KvUserDefined) GTIFGetPMInfo(defn.PM, out dummy, out defn.PMLongToGreenwich);
			else
			{
				GTIFKeyGet(gtif, geokey_t.GeogPrimeMeridianLongGeoKey, out defn.PMLongToGreenwich, 0, 1);
				defn.PMLongToGreenwich=GTIFAngleToDD(defn.PMLongToGreenwich, defn.UOMAngle);
			}

			// --------------------------------------------------------------------
			//		Get the TOWGS84 parameters.
			// --------------------------------------------------------------------
			defn.TOWGS84Count=GTIFKeyGet(gtif, geokey_t.GeogTOWGS84GeoKey, out defn.TOWGS84, 0, 7);

			// --------------------------------------------------------------------
			//		Have the projection units of measure been overridden? We
			//		should likely be doing something about angular units too,
			//		but these are very rarely not decimal degrees for actual
			//		file coordinates.
			// --------------------------------------------------------------------
			GTIFKeyGet(gtif, geokey_t.ProjLinearUnitsGeoKey, out defn.UOMLength, 0, 1);
			if(defn.UOMLength!=(geounits_t)KvUserDefined)
				GTIFGetUOMLengthInfo(defn.UOMLength, out dummy, out defn.UOMLengthInMeters);

			// --------------------------------------------------------------------
			//		Handle a variety of user defined transform types.
			// --------------------------------------------------------------------
			if(GTIFKeyGet(gtif, geokey_t.ProjCoordTransGeoKey, out defn.CTProjection, 0, 1)==1)
				GTIFFetchProjParms(gtif, defn);

			// --------------------------------------------------------------------
			//		Try to set the zoned map system information.
			// --------------------------------------------------------------------
			defn.MapSys=GTIFProjToMapSys(defn.ProjCode, out defn.Zone);

			// --------------------------------------------------------------------
			//		If this is UTM, and we were unable to extract the projection
			//		parameters from the CSV file, just set them directly now,
			//		since it's pretty easy, and a common case.
			// --------------------------------------------------------------------
			if((defn.MapSys==MapSys_UTM_North||defn.MapSys==MapSys_UTM_South)&&
				defn.CTProjection==(coordtrans_t)KvUserDefined)
			{
				defn.CTProjection=coordtrans_t.CT_TransverseMercator;
				defn.nParms=7;
				defn.ProjParmId[0]=geokey_t.ProjNatOriginLatGeoKey;
				defn.ProjParm[0]=0.0;

				defn.ProjParmId[1]=geokey_t.ProjNatOriginLongGeoKey;
				defn.ProjParm[1]=defn.Zone*6-183.0;

				defn.ProjParmId[4]=geokey_t.ProjScaleAtNatOriginGeoKey;
				defn.ProjParm[4]=0.9996;

				defn.ProjParmId[5]=geokey_t.ProjFalseEastingGeoKey;
				defn.ProjParm[5]=500000.0;

				defn.ProjParmId[6]=geokey_t.ProjFalseNorthingGeoKey;

				if(defn.MapSys==MapSys_UTM_North) defn.ProjParm[6]=0.0;
				else defn.ProjParm[6]=10000000.0;
			}

			return true;
		}
コード例 #60
0
ファイル: geo_get.cs プロジェクト: LogoPhonix/libgeotiff.net
		public static int GTIFKeyGet(GTIF gtif, geokey_t thekey, out coordtrans_t val, int index)
		{
			return GTIFKeyGet(gtif, thekey, out val, index, 0);
		}