# GDAL C++ API: How to create PNG or JPEG from scratch

I'm new to GIS and GDAL. My question probably is very basic, but I couldn't find answer. May be I don't understand GDAL ideology.

I need to create raster images from scratch, for example, JPEG or PNG. Their drivers don't support Create function - only CreateCopy. What is the common technique of new files creation in this case?

In principle, I can try to create Tiff because its driver suports Create(). Next, I can use CreateCopy() for PNG or JPEG using this Tiff. But such method looks indirect and unnatural for me. Also I suppose that this procedure can be too memory hungry if rasters are large.

I dealt with some image libraries before, they usually provide direct and simple way of bitmaps creation. Could somebody show me right direction for GDAL?

As user30184 said, in Python, the process would be creating a memory raster of the same dimensions (layers and layer extension), and executing the CreateCopy after that:

driver = gdal.GetDriverByName( 'MEM' ) driver2 = gdal.GetDriverByName( 'PNG' ) ds = driver.Create(", 255, 255, 1, gdal.GDT_Int32) ds2 = driver.CreateCopy('/tmp/out.png">http://www.gdal.org/gdal_tutorial.htmlI'm using GDAL Version 1.11 in C++, that said my answer may not be relevant depending on the version you are using.The theCreate()method is not supported by the PNG driver (I'm not familiar with the JPEG driver), so you must first create aGDALDatasetwith a different driver the use a theCreateCopymethod from a PNG driver to get your PNG image. Also, the PNG driver only supportsGDALDataTypeGDT_UInt16andGDT_Byteso the source dataset you are copying must by one of those types.Here's a little example code…GDALDriver *pDriverTiff, *pDriverPng; GDALDataset *pSourceDS, *pPngDS; //call GDALGetDriverManager to setup the two different drivers //create (or open) the source dataset pSourceDS = pDriverTiff->Create(datasetPath, 300, 300, 1, GDT_Byte, NULL); //use the png driver to copy the source dataset pPngDS = pDriverPNG->CreateCopy(pngPath, pSourceDS, FALSE, NULL, NULL, NULL);  Using my toojpeg library  include the toojpeg.h header file define a callback that accept a single compressed byte  will be called for every byte basically similar to fputc . but can be anything you like, too, e.g. send that byte via network, add it to an std::vector , . call TooJpeg::writeJpeg() hide #include "toojpeg.h" // create your RGB image auto pixels = new unsigned char[ 1024 * 768 * 3 ] // set pixels as you like . // . // define a callback that accepts a single byte void writeByte(unsigned char oneByte) < fputc( oneByte , output) >// . // and start compression ! bool ok = TooJpeg::writeJpeg( writeByte , pixels , width, height) // actually there are some optional parameters, too //bool ok = TooJpeg::writeJpeg(writeByte, pixels, width, height, isRGB, quality, downSample, comment) show example.cpp // ////////////////////////////////////////////////////////// // how to use TooJpeg: creating a JPEG file // see https://create.stephan-brumme.com/toojpeg/ // compile: g++ example.cpp toojpeg.cpp -o example -std=c++11 #include "toojpeg.h" // ////////////////////////////////////////////////////////// // use a C++ file stream #include <fstream> // output file std::ofstream myFile( "example.jpg" , std::ios_base::out | std::ios_base::binary ) // write a single byte compressed by tooJpeg void myOutput(unsigned char byte) < myFile << byte >// ////////////////////////////////////////////////////////// int main() < // 800x600 image const auto width = 800 const auto height = 600 // RGB: one byte each for red, green, blue const auto bytesPerPixel = 3 // allocate memory auto image = new unsigned char[ width * height * bytesPerPixel ] // create a nice color transition (replace with your code) for (auto y = 0 y < height y++) for (auto x = 0 x < width x++) < // memory location of current pixel auto offset = ( y * width + x ) * bytesPerPixel // red and green fade from 0 to 255, blue is always 127 image [ offset ] = 255 * x / width image [ offset + 1 ] = 255 * y / height image [ offset + 2 ] = 127 > // start JPEG compression // note: myOutput is the function defined in line 18, it saves the output in example.jpg // optional parameters: const bool isRGB = true // true = RGB image, else false = grayscale const auto quality = 90 // compression quality: 0 = worst, 100 = best, 80 to 90 are most often used const bool downsample = false // false = save as YCbCr444 JPEG (better quality), true = YCbCr420 (smaller file) const char* comment = "TooJpeg example image" // arbitrary JPEG comment auto ok = TooJpeg::writeJpeg( myOutput , image , width , height , isRGB , quality , downsample , comment ) delete[] image // error => exit code 1 return ok ? 0 : 1 >

The same example, but this time for grayscale images (download file):  show example-gray.cpp // ////////////////////////////////////////////////////////// // how to use TooJpeg: creating a JPEG file // see https://create.stephan-brumme.com/toojpeg/ // compile: g++ example.cpp toojpeg.cpp -o example -std=c++11 #include "toojpeg.h" // ////////////////////////////////////////////////////////// // use a C++ file stream #include <fstream> // output file const char* filename = "example-gray.jpg" std::ofstream myFile( filename , std::ios_base::out | std::ios_base::binary ) // write a single byte compressed by TooJpeg void myOutput(unsigned char byte) < myFile << byte >// ////////////////////////////////////////////////////////// int main() < // 800x600 image const auto width = 800 const auto height = 600 // Grayscale: one byte per pixel const auto bytesPerPixel = 1 // allocate memory auto image = new unsigned char[ width * height * bytesPerPixel ] // create a nice color transition (replace with your code) for (auto y = 0 y < height y++) for (auto x = 0 x < width x++) < // memory location of current pixel auto offset = ( y * width + x ) * bytesPerPixel // red and green fade from 0 to 255, blue is always 127 auto red = 255 * x / width auto green = 255 * y / height image [ offset ] = ( red + green ) / 2 > // start JPEG compression // note: myOutput is the function defined in line 18, it saves the output in example.jpg // optional parameters: const bool isRGB = false // true = RGB image, else false = grayscale const auto quality = 90 // compression quality: 0 = worst, 100 = best, 80 to 90 are most often used const bool downsample = false // false = save as YCbCr444 JPEG (better quality), true = YCbCr420 (smaller file) const char* comment = "TooJpeg example image" // arbitrary JPEG comment auto ok = TooJpeg::writeJpeg( myOutput , image , width , height , isRGB , quality , downsample , comment ) delete[] image // error => exit code 1 return ok ? 0 : 1 >

GDAL C++ API: How to create PNG or JPEG from scratch - Geographic Information Systems Meta Raster Format (MRF) User Guide MRF: Definition, Context and Introduction MRF, short for Meta Raster Format, is a technology that combines raster storage with tile web services and cloud computing. While the main target domain is cloud GIS, the MRF technology can also be used in other areas such as medical imaging and scientific data processing.  A raster storage format A tile cache format for web services A dynamic tile cache for another raster For the purpose of this document, a raster is defined as a two dimensional array of values. In information technology, a raster most commonly represents an image, in which case the array elements are known as pixels, short for picture elements. An image can be grayscale or color. In the latter case multiple values are associated with each pixel, usually one for each of the red, green and blue components. In scientific applications, rasters are commonly used to represent sampled scalar fields or matrices, where each array value is the numeric value of the scalar field at a specific point. In geographic information science (GIS), a raster can be either a map image or an array of values. A raster is a very compact and efficient way of storing uniformly sampled data, since the set of coordinates does not have to be stored with each of the data values. Instead, the coordinates are calculated by knowing the raster projection, one or more reference points and resolution.

gdaladdo -r avg Test.mrf 2 4 8 16 32 64 128 Or for powers of 3: gdaladdo Test.mrf 3 9 27 81 For convenience, unnecessary levels (the large values) generate a warning but not an error. It is not possible to change MRF overviews from one scale factor to another. It is however possible to generate the overviews multiple times, which will not reclaim the space used by the older overviews. While not recommended, it is possible to generate MRF external overviews in GDAL, which are usually not in MRF format and are not subject to the MRF limitations. The MRF driver contains its own optimized resampling code, using either averaging or nearest neighbor algorithms. The internal code has less overhead than the GDAL averaging and is usually faster. It is also optimized for MRFs with large areas of NoData. Use –r avg or -r nnb as the sampling option to gdaladdo with 2 as a scale factor to trigger the use of the MRF specific overview generation. Only scale 2 works for the internal sampler! The MRF sampler pads to the right and bottom of the image when needed, keeping the scale factor an exact 2. In contrast, the GDAL sampler stretches the input when needed by repeating rows and/or columns, which keeps the bounding box for all the overviews identical but the ratio between two successive overviews may not be exactly 2. Since for the internal resampler the scale factor is exactly 2, the avg algorithm can also be considered a bilinear interpolation. Both avg and nbb samplers do take the NoData into account. Note that GDAL up to version 1.11 used an incorrect step when generating overviews. This bug results in inefficient execution, larger than necessary file sizes and sometimes visible artifacts. This problem has been addressed and should not affect future versions of GDAL. Also, use –r average to use the GDAL average interpolation and -r near to select the GDAL nearest neighbor one. As described above, the results will differ slightly from the MRF internal sampler, due to the different padding. For the internal sampler, the progress indicator is per generated level. GDAL resampling takes into consideration both the NoData value and the alpha band when it exists, setting to zero pixels where the alpha band is zero. To force gdal to preserve the data values even for pixels where the alpha value is zero, set the MRF create option PHOTOMETRIC=MULTISPECTRAL . The downside of this workaround is that it will set the photometric interpretation of all bands to unknown, which may create other problems. The MRF avg or nnb resampling methods are not subject to this behavior, it will keep the the data values even if the alpha band is zero. Reading a single overview In case of an MRF file with overviews, it is possible to open a single specific overview level, usually to check the overview in isolation. The overviews are identified by their numeral and not by the relative scale, with 0 being the largest overview. The syntax used for this is <filename>:MRF:L<n>

For example, this command will explicitly open the first overview level: Inserting data in an existing MRF Using an MRF specific utility mrf_insert , it is possible to replace or modify a part of an MRF and generate only the affected portions of the overviews. This facility makes it possible to build very large datasets efficiently, operating on small areas at a time. This functionality relies on the internal MRF resampling, so it will only work with avg or nnb resampling mode and powers of two between levels. Set create option APPEND_SUBDATASET to true avoid deleting the MRF header file. Since a Caching or Cloning MRF may be used at the same time by different processes, the MRF driver contains code that allows it to be written by multiple processes on the same machine safely, as long as the MRF resides on a local disk. This feature might be useful for other types of MRF, for example when mrf_insert is used to update different areas of the same file, or when multiple third dimension MRF Z-Slices can be written to at the same time. To turn on this feature, manually add a boolean attribute called mp_safe with the value on to the Raster node of the MRF metadata. This feature is not on by default since it slows down the write operations somewhat. This feature has been tested on Windows and Linux, and it may fail on specific operating and file system implementations. It does not work on shared, network file systems like CIFS and NFS, because these file systems do not implement the file append mode correctly. Types of tile compressions supported by MRF Tiles in an MRF are stored using one of the multiple supported packing or compression formats. Some of the formats are themselves standard raster formats like JPEG, TIFF or PNG, while others are only compression formats. The choice of the tile format is passed to the MRF driver using the GDAL create option COMPRESS . As the name suggest, the NONE format directly stores the tile array, in a row major pixel order. PIXEL and BAND interleave modes are supported, as well as all the GDAL supported data types. The NONE format has no other options or features, all the common MRF functionality applies. If a NoData value is defined per band, tiles consisting only in NoData values are not stored on disk. If the NoData value is not defined, tiles which only contain zeros are not stored. As with any other tile format, the MRF does not guarantee any specific order of the tiles in the data file. DEFLATE is a well known generic compression algorithm, implemented in the open source zlib library. In MRF it can be used in two ways, as a stand-alone tile packing mechanism and also as a second compression step to other compression formats. The second meaning is activated by adding DEFLATE:on to the free form list OPTIONS . None compression with the DEFLATE:on option is equivalent to the DEFLATE as compression format, even though the content of the metadata file is different. The following two commands should generate MRFs with identical size data files, although the tile order may differ.

The JPEG compression is a well know lossless image compression, tuned for good visual quality combined with good compression. Since JPEG is a well known format, the MRF tiles compressed as JPEG are suitable for serving as web tiles. Depending on how the GDAL MRF was built, the MRF/JPEG format can handle 8 and sometimes 12 bit data. The 12 bit option is only available when the GDAL internal libJPEG is used and the GDAL 12bit JPEG is enabled. MRF/JPEG can handle up to 10 bands in pixel interleave mode. Note that only 8 bit JPEGs with 1 or 3 bands are suitable for web tile services in most cases. The MRF QUALITY output option value is directly passed to JPEG library as the Q factor, with the default value being 85. Note that the JPEG Q value does control the output quality and size, but it is not linear. For the exact interpretation of Q, please consult JPEG documentation. Values between 0 and 100 are supported, the reasonable range being between sixty and eighty five, larger values producing visually better results at the cost of increased size. For three bands interleaved, a couple of encoding options are available, controlled via the PHOTOMETRIC setting. The default setting should be used most of the time. The valid choices for the PHOTOMETRIC setting are:  DEFAULT: JPEG uses YCbCr, 4:2:0 sampling internally. This provides good compression and visual quality. The color space has significantly lower quality than the brightness, which roughly matches the human vision charateristics. YCC : Compressed as YCbCr with 4:4:4 sampling, ie color space is not spatially resampled. This setting produces tiles about a third larger than the default, tiles which have fewer color artifacts. The color conversion itself still results in a loss of information, as well as the quantization. RGB : Compressed as RGB, not color converted and not spatially resampled. This setting produces much larger JPEG files, usually twice as large or more. Files are about three times larger than with the default setting. MRF with this setting can be decoded and re-encoded multiple times at the same quality without any data quality degradation.

The Zen bitmask is organized in a 8x8 2D bitmask, which is then compressed by run length encoding (RLE). For most inputs, the size of the Zen chunk containing the mask is negligible. The potential benefit of being able to treat black as transparent outweigh this size increase thus this feature cannot be turned off. The JPNG compression is a combination of PNG or JPEG tiles, depending on the presence of non-opaque pixels. If all the pixels within a tile are opaque the tile is stored as JPEG, otherwise it is stored as PNG with an Alpha channel. It is presented to GDAL as either a Luma-Alpha or RGBA image, it will always have 2 or 4 bands, and always PIXEL interleaved. Most of the MRF options from PNG and from JPEG compression still apply, including the JFIF flag. The data file will be smaller than when using only PNG, if there are tiles that are fully opaque and can be stored as JPEG. Note that depending on the options used and the input data, the transition from PNG to JPEG might be visible. The normal JPEG with Zen mask should be used in most cases, except if 0 is not to be transparent and when gradual transparency is needed. Another advantage over MRF/JPEG/Zen is that legacy clients such as web browser applications do not usually need modification to be able to display the tiles as intended. In the MRF with TIFF compression, every tile is a TIFF raster which uses the lossless LZW internal compression. Most data types are supported. Note that the tiles are not GeoTiffs, they do not contain geotags. This compression is mostly useful for web services for certain clients which support decoding TIFF. Limited Error Raster Compression (LERC) is an original Esri raster compression format. The main benefit of using LERC is extremely fast operation when compared with PNG, DEFLATE and even with JPEG, as well as excellent compression for data types larger than eight bit. The LERC compression can be either lossy or lossless. The lossy part is due to an initial quantization stage, which is controled by the LERC maximum error value (LERC_PREC), which is a floating point number. LERC may alter the values stored, but the change is always less or equal to this LERC maximum error value. The quanta or precision of the output data values will thus be twice the LERC_PREC value. If the LERC maximum error is zero or too small for any space savings to be obtained by quantization, the input data values are not modified, and LERC becomes a lossless format. LERC supports an explicit data mask, which in MRF is enabled when the NoData value is defined. The NoData values are not stored in the compressed tile, which makes LERC a good choice for storing sparse data. In MRF, for integer types the default LERC_PREC value is 0.5, corresponding to lossless compression. For floating point types the LERC_PREC defaults to 0.001 (.002 data resolution). The compression achieved by LERC heavily depends on the LERC_PREC value, which should be carefully selected for each particular dataset.

APPENDIX A, MRF Metadata Schema APPENDIX B, Index file format The MRF index is a vector of tile records. A tile index record is sixteen bytes long and contains the tile offset and size, each stored as an eight byte unsigned integer. In C, a tile index record is defined as Example values in this document will be using the notation [Offset, Size] for a tile index. By convention the index for a tile which has no data written into it has the size of zero [R, 0]. This index record will generate a tile filled with zeros or NoData on read. The value for the offset is reserved and should be written as zero. An offset value of 1 and a size of 0 [1, 0] is used by the caching/cloning MRFs as a flag that a tile is zero or NoData in the source file. It will be read as zero without triggering a read from the source. The order of the tile records in the index file depends on the type of MRF: Tile records are usually stored in top-left orientation, in row major order (Y, X). If the MRF contains multiple channels (Bands) and they are stored as band interleaved data, the band index changes first, then the spatial index (Y, X, C). If the MRF Z dimension is more than 1, each Z slice index is stored consecutively, thus Z varies after Y (Z, Y, X, C). If the MRF contains versions, the current version is stored at the start of the index file, immediately followed by version one and so on (V, Y, X, C) or (V, Z, Y, X, C). If there are overviews, the tile index vectors for the overviews immediately follow the index vector for the full resolution, in the decreasing order of resolution, (lX,Y,C) or (lZ,X,Y,C). Note that the vector for an overview level is smaller than the vector for the previous overview or base resolution. For cloning MRFs, the index of the local cache data is followed immediately by a copy of the cloned MRF index. The content of both may be updated during reads. To print the content of the index in a human readable form, the following command can be used on UNIX. The first number is the offset, the second one the size of each tile APPENDIX C, Create Options In GDAL, a list of key-value string pairs can be used to pass various options to the target driver. Using the gdal_translate utility, these options are passed using the –co Key=Value syntax. Most of the names of the options supported by MRF have been chosen to match the ones used by TIFF. The create options supported by MRF are:

Key Default Value Description   BLOCKSIZE 512 The tile size, in both X and Y BLOCKXSIZE 512 Horizontal tile size BLOCKYSIZE 512 Vertical tile size COMPRESS PNG Choses the tile packing algorithm ZSIZE 1 Specifies the third dimension size INTERLEAVE PIXEL or BAND, format dependent PIXEL or BAND interleave NETBYTEORDER FALSE If true, for some packings, forces endianness dependent input data to big endian when writing, and back to native when reading QUALITY 85 An integer, 0 to 100, used to control the compression PHOTOMETRIC Sets the interpretation of the bands and controls some of the compression algorithms SPACING 0 Reserve this many bytes before each tile data NOCOPY False Create an empty MRF, do not copy input UNIFORM_SCALE Flags the MRF as containing overviews, with a given numerical scale factor between successive overviews CACHEDSOURCE GDAL raster reference to be cached in the caching MRF being created

APPENDIX D, Free-form Create Options In addition to the normal create options which are applicable to all supported tile packings, MRF compressions also accept a set of options that control features of only specific packing formats, or can be used to modify default behaviors. The main difference between the create options and free-form options is that the latter are saved in the MRF metadata file and may apply when a file is read, not only when it is written. The free form options are not part of the GDAL interface, and as such they are not checked for correctness when passed to the driver. If a free form option doesn't seem to have the expected effect, the exact spelling should be checked, they are case sensitive. The free-form option list is passed as a single string value for the create option called OPTIONS. The value is a free form string containing white space separated key value pairs. GDAL list parsing is being used when reading, either the equal sign = or the colon : can be used as the separator between key and value. Boolean flags are false by default, they are treated as true only if the value is one of the Yes , True or 1 . When using gdal_translate utility, the free form option syntax will be: -co OPTIONS="Key1:Value1 Key2:Value2 …"

Key Default Packing Description   DEFLATE False Most Apply zlib DEFLATE as a final packing stage GZ False DEFLATE Generate gzip header style RAWZ False DEFLATE No zlib or gzip headers Z_STRATEGY PNG, DEFLATE DEFLATE algorithmic choice: Z_HUFFMAN_ONLY, Z_FILTERED, Z_RLE, Z_FIXED V1 False LERC Uses LERC1 compression instead of LERC (V2) LERC_PREC 0.5 for integer types 0.001 for floating point LERC Maximum value change allowed OPTIMIZE False JPEG, JPNG Optimize the Huffman tables for each tile. Always true for JPEG12 JFIF False JPEG, JPNG When set, write JPEG tiles in JFIF format. By default, brunsli format is preferred

Starting with GDAL 2.x, a list of key-value string pairs can be used to pass various options to the target driver when reading. Using the gdal_translate utility, these options are passed using the –oo Key=Value syntax.  ◆ ImwritePNGFlags Imwrite PNG specific flags used to tune the compression algorithm. These flags will be modify the way of PNG image compression and will be passed to the underlying zlib processing stage.  The effect of IMWRITE_PNG_STRATEGY_FILTERED is to force more Huffman coding and less string matching it is somewhat intermediate between IMWRITE_PNG_STRATEGY_DEFAULT and IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY. IMWRITE_PNG_STRATEGY_RLE is designed to be almost as fast as IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. IMWRITE_PNG_STRATEGY_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. Use this value for normal data. Use this value for data produced by a filter (or predictor).Filtered data consists mostly of small values with a somewhat random distribution. In this case, the compression algorithm is tuned to compress them better. Use this value to force Huffman encoding only (no string match). Use this value to limit match distances to one (run-length encoding). Using this value prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications.  ◆ imwrite()  bool cv::imwrite ( const String & filename, InputArray  img, const std::vector< int > & params = std::vector< int >() )Python: cv.imwrite(filename, img[, params]) -> retval

Saves an image to a specified file. The function imwrite saves the image to the specified file. The image format is chosen based on the filename extension (see cv::imread for the list of extensions). In general, only 8-bit single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function, with these exceptions:  16-bit unsigned (CV_16U) images can be saved in the case of PNG, JPEG 2000, and TIFF formats 32-bit float (CV_32F) images can be saved in TIFF, OpenEXR, and Radiance HDR formats 3-channel (CV_32FC3) TIFF images will be saved using the LogLuv high dynamic range encoding (4 bytes per pixel) PNG images with an alpha channel can be saved using this function. To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha channel goes last. Fully transparent pixels should have alpha set to 0, fully opaque pixels should have alpha set to 255/65535 (see the code sample below). Multiple images (vector of Mat) can be saved in TIFF format (see the code sample below). If the image format is not supported, the image will be converted to 8-bit unsigned (CV_8U) and saved that way. If the format, depth or channel order is different, use Mat::convertTo and cv::cvtColor to convert it before saving. Or, use the universal FileStorage I/O functions to save the image to XML or YAML format. The sample below shows how to create a BGRA image, how to set custom compression parameters and save it to a PNG file. It also demonstrates how to save multiple images in a TIFF file:  GDAL C++ API: How to create PNG or JPEG from scratch - Geographic Information Systems An error has been encountered in accessing this page. 1. Server: www.libpng.org 2. URL path: /pub/png/pngcode.html 3. Error notes: Server unable to read htaccess file, denying access to be safe 4. Error type: 403 5. Request method: GET 6. Request query string: NONE 7. Time: 2021-06-27 20:08:24 UTC (1624824504) Reporting this problem: The problem you have encountered is with a project web site hosted by SourceForge.net. This issue should be reported to the SourceForge.net-hosted project (not to SourceForge.net).  Contact the project via their designated support resources. Contact the project administrators of this project via email (see the upper right-hand corner of the Project Summary page for their usernames) at user-name@users.sourceforge.net If you are a maintainer of this web content, please refer to the Site Documentation regarding web services for further assistance. NOTE: As of 2008-10-23 directory index display has been disabled by default. This option may be re-enabled by the project by placing a file with the name ".htaccess" with this line:

var s1= document.location.host;

Watch the video: Generating Code in RepreZen API Studio (September 2021).


 
 
 /*<![CDATA[*/ MathJax.Ajax.config.path["mhchem"] = "https://cdnjs.cloudflare.com/ajax/libs/mathjax-mhchem/3.3.2"; MathJax.Hub.Config({ jax: ["input/TeX","input/MathML","output/SVG"], extensions: ["tex2jax.js","mml2jax.js","MathMenu.js","MathZoom.js"], TeX: { extensions: ["autobold.js","mhchem.js","color.js","cancel.js", "AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"] }, "HTML-CSS": { linebreaks: { automatic: true , width: "90%"}, scale: 85, mtextFontInherit: false}, menuSettings: { zscale: "150%", zoom: "Double-Click" }, SVG: { linebreaks: { automatic: true } }}); /*]]>*/ Interesting Articles 8.6: Flumes - Geosciences September 28,2021 MODIS MOD10A2 snow product September 28,2021 Web Application with data editing capabilities by users stored in Geoserver September 28,2021 
 (adsbygoogle = window.adsbygoogle || []).push({}); Recommended Splitting lines with points while maintaining other dissolved lines? More Updating attribute table from an Excel file using Python More Satellite Images of Countries, States, U.S. Cities and World Cities More (adsbygoogle = window.adsbygoogle || []).push({}); (adsbygoogle = window.adsbygoogle || []).push({}); Popular Posts, 2021 12.1: Stress and Strain - Geosciences More What are nodes in ArcGIS and how do you create them? More Making 'persistent' ArcMap tool without creating Python add-in? More Raster clipping outside area in ArcMap? More GeoServer 2.7.1 fails to start after installing 11-Aug-2015 scripting extension More (adsbygoogle = window.adsbygoogle || []).push({}); (adsbygoogle = window.adsbygoogle || []).push({}); 
 
 
 Copyright 2021 \ Geology and Earth Sciences news, articles, photos, maps, and more \ GDAL C++ API: How to create PNG or JPEG from scratch 
 
 jQuery(document).ready(function($){$('.accordion-shortcode').find('.accordion-item-title').click(function(e){e.preventDefault();$(this).next().slideToggle(200);$(".accordion-item-content").not(\$(this).next()).slideUp(200);});}); var raspberry_iron_site_smooth_display="1"; var raspberry_iron_to_top="1";var raspberry_iron_to_top_mobile="1";var raspberry_iron_site_smooth_scroll="1";var raspberry_iron_site_smooth_display="1";var raspberry_iron_single_image_popup="1";var raspberry_iron_sticky_navigation="1"; eval(mod_pagespeed_PXnt_6glbt); eval(mod_pagespeed_6biOeGBGFy); (function(m,e,t,r,i,k,a){ m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)}; m[i].l=1*new Date(); k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a) })(window, document,"script","//mc.yandex.ru/metrika/tag.js", "ym"); ym(56695798, "init", {accurateTrackBounce:true, trackLinks:true, webvisor:true, clickmap:true, params: {__ym: {isFromApi: "yesIsFromApi"}}}); new Image().src = "//counter.yadro.ru/hit?r" + escape(document.referrer) + ((typeof(screen)=="undefined")?"" : ";s"+screen.width+"*"+screen.height+"*" + (screen.colorDepth?screen.colorDepth:screen.pixelDepth)) + ";u"+escape(document.URL) + ";" +Math.random();