/// <summary> /// Initializes a new instance of the <see cref="GribFile" /> class. File read rights are shared between processes. /// </summary> /// <param name="fileName">Name of the file.</param> /// <exception cref="System.IO.IOException">Could not open file. See inner exception for more detail.</exception> /// <exception cref="System.IO.FileLoadException">The file is empty.</exception> public GribFile(string fileName) { FileInfo fi = new FileInfo(fileName); // need a better check if (fi.Length < 4) { throw new FileLoadException("This file is empty or invalid."); } _pFileHandleProxy = GribApiNative.CreateFileHandleProxy(fileName); if (_pFileHandleProxy == IntPtr.Zero) { throw new IOException("Could not open file. See inner exception for more detail.", new Win32Exception(Marshal.GetLastWin32Error())); } _fileHandleProxy = (FileHandleProxy)Marshal.PtrToStructure(_pFileHandleProxy, typeof(FileHandleProxy)); FileName = fileName; Reference = new HandleRef(this, _fileHandleProxy.File); Context = GribApiProxy.GribContextGetDefault(); // set the message count here; the result seems to be connected to the message iterator so // that after you begin iterating messages, the count decreases until it reaches 1. int count = 0; GribApiProxy.GribCountInFile(Context, this, out count); MessageCount = count; }
/// <summary> /// /// </summary> /// <param name="bits"></param> /// <param name="index"></param> /// <param name="ctx"></param> /// <returns></returns> public static GribMessage Create(byte[] bits, int index, GribContext ctx) { var buff = Marshal.AllocHGlobal(bits.Length); Marshal.Copy(bits, 0, buff, bits.Length); int err = 0; SizeT sz = (SizeT)bits.Length; GribMessage msg = null; GribHandle handle = null; lock (_fileLock) { // grib_api moves to the next message in a stream for each new handle handle = GribApiProxy.GribHandleNewFromMultiMessage(ctx, out buff, ref sz, out err); } if (err != 0) { Marshal.AllocHGlobal(buff); throw GribApiException.Create(err); } if (handle != null) { msg = new GribMessage(handle, ctx, buff, index); } return(msg); }
/// <summary> /// Called when [dispose]. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void OnDispose(bool disposing) { if (this.pReference != IntPtr.Zero) { this.Rewind(); GribApiProxy.GribKeysIteratorDelete(this); } }
/// <summary> /// Gets an enum describing a key's representation within the message. /// </summary> /// <param name="key">The key.</param> /// <returns></returns> private GribValueType NativeTypeForKey(string key) { int type = 0; GribApiProxy.GribGetNativeType(_handle, key, out type); return((GribValueType)type); }
/// <summary> /// Sets the key's value in bytes. /// </summary> /// <param name="newBytes">The new bytes.</param> public void AsBytes(byte[] newBytes) { AssertTypeSafe(GribValueType.Bytes); SizeT sz = (SizeT)newBytes.Length; GribApiProxy.GribSetBytes(_handle, Key, newBytes, ref sz); }
/// <summary> /// Sets the key's value. /// </summary> /// <param name="newValue">The new value.</param> public virtual void AsString(string newValue) { AssertTypeSafe(GribValueType.String); SizeT len = (SizeT)newValue.Length; GribApiProxy.GribSetString(_handle, Key, newValue, ref len); }
/// <summary> /// Sets the key's value. /// </summary> /// <param name="newValue">The new value.</param> public virtual void AsDouble(double newValue) { string valueKey = BuildTokenForDouble(); AssertTypeSafe(valueKey, NativeTypeForKey(valueKey), GribValueType.Double); GribApiProxy.GribSetDouble(_handle, valueKey, newValue); }
/// <summary> /// Retrieves the GRIB key's type name. /// </summary> /// <param name="vt">The vt.</param> /// <returns></returns> public static string AsString(this GribValueType vt) { if ((int)vt >= (int)GribValueType.IntArray) { return(vt.ToString()); } return(GribApiProxy.GribGetTypeName((int)vt)); }
/// <summary> /// Gets the next value in a series. /// </summary> /// <param name="isMissingFlag">The is missing flag.</param> /// <param name="gsVal">The gs value.</param> /// <returns>False if there are no more values.</returns> public bool Next(double isMissingFlag, out GridCoordinateValue gsVal) { double lat, lon, val; bool success = GribApiProxy.GribIteratorNext(this, out lat, out lon, out val) != 0; gsVal = new GridCoordinateValue(lat, lon, val, val == isMissingFlag); return(success); }
protected override void OnDispose(bool disposing) { if (this.pReference != IntPtr.Zero) { GribApiProxy.GribNearestDelete(Nearest); this.Nearest = null; this.Handle = null; } }
/// <summary> /// Gets the key's value. /// </summary> /// <returns></returns> public virtual int AsInt() { AssertTypeSafe(GribValueType.Int); int val; GribApiProxy.GribGetLong(_handle, Key, out val); return(val); }
/// <summary> /// Gets the key's value. /// </summary> /// <returns></returns> public virtual double AsDouble() { string valueKey = BuildTokenForDouble(); AssertTypeSafe(valueKey, NativeTypeForKey(valueKey), GribValueType.Double); double val; GribApiProxy.GribGetDouble(_handle, valueKey, out val); return(val); }
/// <summary> /// Creates an instance of GribValuesIterator. /// </summary> /// <param name="h">The handle of the message to iterate.</param> /// <param name="filters">The filters.</param> /// <returns></returns> public static GribCoordinateValuesIterator Create(GribHandle h, uint filters) { int err = 0; GribCoordinateValuesIterator iter = GribApiProxy.GribIteratorNew(h, filters, out err); if (err != 0) { throw GribApiException.Create(err); } return(iter); }
///// <summary> ///// Find the nearest point of a set of points whose latitudes and longitudes. ///// </summary> ///// <param name="coordinates">The reference coordinates.</param> ///// <param name="useLandSeaMask">If true, the nearest land point is returned and the grib passed as the handle is considered a land sea mask. ///// land nearest point is the nearest point with land sea mask value>=0.5. If no nearest land points are found the nearest value is returned. ///// If the flag false, the nearest points, along with values, distances, and indexes are returned. ///// </param> ///// <returns></returns> //public GribNearestCoordinate[] FindNearestCoordinates(IGeoCoordinate[] coordinates, bool useLandSeaMask = false) //{ // var len = coordinates.Length; // var latitudes = new double[len]; // var longitudes = new double[len]; // var outLatitudes = new double[len]; // var outLongitudes = new double[len]; // var distances = new double[len]; // var values = new double[len]; // var indexes = new int[len]; // for (var i = 0; i < len; i++) // { // latitudes[i] = coordinates[i].Latitude; // longitudes[i] = coordinates[i].Longitude; // } // Interop.SizeT sz = (SizeT)len; // Interop.SWIG.GribApiProxy.GribNearestFindMultiple(this.Handle, useLandSeaMask ? 1 : 0, latitudes, longitudes, len, // outLatitudes, outLongitudes, values, distances, indexes); // var vals = new GribNearestCoordinate[len]; // for (var i = 0; i < len; i++) // { // vals[i] = new GribNearestCoordinate(latitudes[i], longitudes[i], values[i], distances[i], indexes[i]); // } // Array.Sort(vals, (v1, v2) => v1.Distance.CompareTo(v2.Distance)); // return vals; //} public static GribNearest Create(GribHandle handle) { int err = 0; var nearest = GribApiProxy.GribNearestNew(handle, out err); if (err != 0) { throw GribApiException.Create(err); } return(new GribNearest(nearest, handle)); }
/// <summary> /// Sets the key's value. /// </summary> /// <param name="newValues">The new values.</param> /// <param name="force">if set to <c>true</c> [force].</param> public virtual void AsDoubleArray(double[] newValues, bool force = false) { if (force) { GribApiProxy.GribSetForceDoubleArray(_handle, Key, newValues, (SizeT)newValues.Length); } else { AssertTypeSafe(GribValueType.DoubleArray); GribApiProxy.GribSetDoubleArray(_handle, Key, newValues, (SizeT)newValues.Length); } }
/// <summary> /// Gets the key's value in bytes. /// </summary> /// <returns></returns> public byte[] AsBytes() { AssertTypeSafe(GribValueType.Bytes); SizeT sz = 0; GribApiProxy.GribGetSize(_handle, Key, ref sz); byte[] bytes = new byte[sz]; GribApiProxy.GribGetBytes(_handle, Key, bytes, ref sz); return(bytes); }
/// <summary> /// Gets a copy of the key's array value. Changing the values of this array does not affect the owning message. /// Call ::AsXArray(alteredArray) to set new values. /// </summary> /// <returns>Returns a *copy* of the key's array.</returns> public virtual int[] AsIntArray() { AssertTypeSafe(GribValueType.IntArray); SizeT sz = 0; GribApiProxy.GribGetSize(_handle, Key, ref sz); int[] values = new int[sz]; GribApiProxy.GribGetLongArray(_handle, Key, values, ref sz); return(values); }
/// <summary> /// Gets a copy of the key's array value. Changing the values of this array does not affect the owning message. /// Call ::AsXArray(alteredArray) to set new values. /// </summary> /// <returns>Returns a *copy* of the key's array.</returns> public virtual double[] AsDoubleArray() { AssertTypeSafe(GribValueType.DoubleArray); SizeT sz = 0; GribApiProxy.GribGetSize(_handle, Key, ref sz); double[] values = new double[sz]; GribApiProxy.GribGetDoubleArray(_handle, Key, values, ref sz); return(values); }
/// <summary> /// Gets the key's value. /// </summary> /// <param name="inDegrees">if set to <c>true</c>, GribApi.NET will return the value [in degrees] when possible.</param> /// <returns></returns> public virtual double AsDouble(bool inDegrees = true) { string valueKey = BuildTokenForDouble(inDegrees); AssertTypeSafe(valueKey, NativeTypeForKey(valueKey), GribValueType.Double); if (!IsDefined) { return(Double.NaN); } double val; GribApiProxy.GribGetDouble(_handle, valueKey, out val); return(val); }
/// <summary> /// Creates a GribMessage instance from a <seealso cref="Grib.Api.GribFile"/>. /// </summary> /// <param name="file">The file.</param> /// <param name="index">The index.</param> /// <returns></returns> public static GribMessage Create(GribFile file, int index) { GribMessage msg = null; int err = 0; // grib_api moves to the next message in a stream for each new handle GribHandle handle = GribApiProxy.GribHandleNewFromFile(file.Context, file, out err); if (err != 0) { throw GribApiException.Create(err); } if (handle != null) { msg = new GribMessage(handle, file.Context, index); } return(msg); }
/// <summary> /// Initializes a new instance of the <see cref="GribBox"/> class. /// </summary> /// <param name="msgHandle">The MSG handle.</param> /// <param name="nw">The nw.</param> /// <param name="se">The se.</param> public GribBox(GribHandle msgHandle, GeoCoordinate nw, GeoCoordinate se) { int err; var box = GribApiProxy.GribBoxNew(msgHandle, out err); if (err != 0) { throw GribApiException.Create(err); } var pts = GribApiProxy.GribBoxGetPoints(box, nw.Latitude, nw.Longitude, se.Latitude, se.Longitude, out err); if (err != 0) { throw GribApiException.Create(err); } _points = new GribPoints(SWIGTYPE_p_grib_points.getCPtr(pts).Handle, false); }
public bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { disposedValue = true; if (this._nearest != null) { this._nearest.Dispose(); } if (this.BufferHandle.IsAllocated) { SWIGTYPE_p_grib_multi_handle mh = new SWIGTYPE_p_grib_multi_handle(this.Handle.Reference.Handle, false); GribApiProxy.GribMultiHandleDelete(mh); this.BufferHandle.Free(); } } }
public bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { disposedValue = true; if (this._nearest != null) { this._nearest.Dispose(); } if (this.OwnsMemory) { SWIGTYPE_p_grib_multi_handle mh = new SWIGTYPE_p_grib_multi_handle(this.Handle.Reference.Handle, false); GribApiProxy.GribMultiHandleDelete(mh); // Marshal.FreeHGlobal(this.NativeBuffer); this.NativeBuffer = IntPtr.Zero; } } }
/// <summary> /// Gets the key's value. /// </summary> /// <returns></returns> public virtual string AsString() { if (!IsDefined || _asStringBlacklist.Contains(NativeType)) { return(String.Empty); } SizeT ptLen = 0; string valueKey = Key; if (CanConvertToDegrees) { valueKey = BuildTokenForDouble(); } // not sure it's worth checking the length here--could just use MAX_VAL_LEN GribApiProxy.GribGetLength(_handle, valueKey, ref ptLen); StringBuilder msg = new StringBuilder((int)ptLen); GribApiProxy.GribGetString(_handle, valueKey, msg, ref ptLen); return(msg.ToString().Trim()); }
/// <summary> /// Creates a GribMessage instance from a buffer. /// </summary> /// <param name="bits"></param> /// <param name="index"></param> /// <returns></returns> public static GribMessage Create(byte[] bits, int index = 0) { GCHandle h = GCHandle.Alloc(bits, GCHandleType.Pinned); IntPtr pHandle = h.AddrOfPinnedObject(); int err = 0; SizeT sz = (SizeT)bits.Length; GribHandle handle = GribApiProxy.GribHandleNewFromMultiMessage(GribContext.Default, out pHandle, ref sz, out err); if (err != 0) { h.Free(); throw GribApiException.Create(err); } GribMessage msg = null; if (handle != null) { msg = new GribMessage(handle, GribContext.Default, h, index); } return(msg); }
/// <summary> /// Creates an instance of GribKeysIterator. /// </summary> /// <param name="handle">The handle of the message to iterate.</param> /// <param name="filters">The key filters.</param> /// <param name="nspace">The namespace of the keys to iterate.</param> /// <returns></returns> public static GribKeysIterator Create(GribHandle handle, uint filters, string nspace) { return(GribApiProxy.GribKeysIteratorNew(handle, filters, nspace)); }
/// <summary> /// Rewinds this instance. /// </summary> public void Rewind() { GribApiProxy.GribKeysIteratorRewind(this); }
/// <summary> /// Return true if the key name exists (is defined) in the grib message. /// </summary> /// <param name="handle"></param> /// <param name="keyName"></param> /// <returns></returns> public static bool IsKeyDefined(GribHandle handle, string keyName) { return(GribApiProxy.GribIsDefined(handle, keyName)); }
/// <summary> /// Sets the key's value. /// </summary> /// <param name="newValue">The new value.</param> public virtual void AsInt(int newValue) { AssertTypeSafe(GribValueType.Int); GribApiProxy.GribSetLong(_handle, Key, newValue); }
/// <summary> /// Sets the key's value. /// </summary> /// <param name="newValues">The new values.</param> public virtual void AsIntArray(int[] newValues) { AssertTypeSafe(GribValueType.IntArray); GribApiProxy.GribSetLongArray(_handle, Key, newValues, (SizeT)newValues.Length); }