Copilot commented on code in PR #2802:
URL: https://github.com/apache/sedona/pull/2802#discussion_r3005914667
##########
docs/tutorial/raster.md:
##########
@@ -503,47 +565,93 @@ Please refer to [Raster visualizer
docs](../api/sql/Raster-Functions.md#raster-o
## Save to permanent storage
-Sedona has APIs that can save an entire raster column to files in a specified
location. Before saving, the raster type column needs to be converted to a
binary format. Sedona provides several functions to convert a raster column
into a binary column suitable for file storage. Once in binary format, the
raster data can then be written to files on disk using the Sedona file storage
APIs.
-
-```sparksql
-rasterDf.write.format("raster").option("rasterField",
"raster").option("fileExtension",
".tiff").mode(SaveMode.Overwrite).save(dirPath)
-```
+Saving raster data is a two-step process: (1) convert the Raster column to
binary format using an `RS_AsXXX` function, and (2) write the binary DataFrame
to files using Sedona's `raster` data source writer.
-Sedona has a few writer functions that create the binary DataFrame necessary
for saving the raster images.
+### Step 1: Convert to binary format
-### As Arc Grid
+Choose one of the following output format functions:
-Use [RS_AsArcGrid](../api/sql/Raster-writer.md#rs_asarcgrid) to get the binary
Dataframe of the raster in Arc Grid format.
+| Function | Format | Description |
+| :--- | :--- | :--- |
+| [RS_AsGeoTiff](../api/sql/Raster-Output/RS_AsGeoTiff.md) | GeoTiff |
General-purpose raster format with optional compression |
+| [RS_AsCOG](../api/sql/Raster-Output/RS_AsCOG.md) | Cloud Optimized GeoTiff |
Ideal for cloud storage with efficient range-read access |
+| [RS_AsArcGrid](../api/sql/Raster-Output/RS_AsArcGrid.md) | Arc Grid |
ASCII-based format, single band only |
+| [RS_AsPNG](../api/sql/Raster-Output/RS_AsPNG.md) | PNG | Image format,
unsigned integer pixel types only |
```sql
-SELECT RS_AsArcGrid(raster)
+SELECT RS_AsGeoTiff(rast) AS raster_binary FROM rasterDf
```
-### As GeoTiff
+### Step 2: Write to files
-Use [RS_AsGeoTiff](../api/sql/Raster-writer.md#rs_asgeotiff) to get the binary
Dataframe of the raster in GeoTiff format.
+Use Sedona's built-in `raster` data source to write the binary DataFrame:
-```sql
-SELECT RS_AsGeoTiff(raster)
-```
+=== "Scala"
+ ```scala
+ rasterDf.withColumn("raster_binary", expr("RS_AsGeoTiff(rast)"))
+ .write.format("raster").mode("overwrite").save("my_raster_file")
+ ```
-### As Cloud Optimized GeoTiff
+=== "Python"
+ ```python
+ rasterDf.withColumn("raster_binary",
expr("RS_AsGeoTiff(rast)")).write.format(
+ "raster"
+ ).mode("overwrite").save("my_raster_file")
+ ```
-Use [RS_AsCOG](../api/sql/Raster-writer.md#rs_ascog) to get the binary
Dataframe of the raster in [Cloud Optimized GeoTiff](https://www.cogeo.org/)
(COG) format. COG is ideal for cloud-hosted raster data because it supports
efficient range-read access over HTTP.
+The writer data source options are:
-```sql
-SELECT RS_AsCOG(raster)
-```
+| Option | Default | Description |
+| :--- | :--- | :--- |
+| `rasterField` | The `binary` type column | The name of the binary column to
write. Required if the DataFrame has multiple binary columns. |
+| `fileExtension` | `.tiff` | File extension for output files (e.g., `.png`,
`.asc`). |
+| `pathField` | None | Column name containing the output file paths. If not
set, each file gets a random UUID name. |
Review Comment:
The `pathField` option description implies full output paths, but the writer
only uses the base name (drops any directory components) and also strips an
existing extension before appending `fileExtension`. Update this table entry to
describe the actual behavior (and avoid suggesting users can control output
subdirectories via `pathField`).
```suggestion
| `pathField` | None | Column name containing the output file names (base
names). Any directory components are ignored, and any existing extension is
stripped before appending `fileExtension`. If not set, each file gets a random
UUID name. |
```
##########
docs/tutorial/raster.md:
##########
@@ -503,47 +565,93 @@ Please refer to [Raster visualizer
docs](../api/sql/Raster-Functions.md#raster-o
## Save to permanent storage
-Sedona has APIs that can save an entire raster column to files in a specified
location. Before saving, the raster type column needs to be converted to a
binary format. Sedona provides several functions to convert a raster column
into a binary column suitable for file storage. Once in binary format, the
raster data can then be written to files on disk using the Sedona file storage
APIs.
-
-```sparksql
-rasterDf.write.format("raster").option("rasterField",
"raster").option("fileExtension",
".tiff").mode(SaveMode.Overwrite).save(dirPath)
-```
+Saving raster data is a two-step process: (1) convert the Raster column to
binary format using an `RS_AsXXX` function, and (2) write the binary DataFrame
to files using Sedona's `raster` data source writer.
-Sedona has a few writer functions that create the binary DataFrame necessary
for saving the raster images.
+### Step 1: Convert to binary format
-### As Arc Grid
+Choose one of the following output format functions:
-Use [RS_AsArcGrid](../api/sql/Raster-writer.md#rs_asarcgrid) to get the binary
Dataframe of the raster in Arc Grid format.
+| Function | Format | Description |
+| :--- | :--- | :--- |
+| [RS_AsGeoTiff](../api/sql/Raster-Output/RS_AsGeoTiff.md) | GeoTiff |
General-purpose raster format with optional compression |
+| [RS_AsCOG](../api/sql/Raster-Output/RS_AsCOG.md) | Cloud Optimized GeoTiff |
Ideal for cloud storage with efficient range-read access |
+| [RS_AsArcGrid](../api/sql/Raster-Output/RS_AsArcGrid.md) | Arc Grid |
ASCII-based format, single band only |
+| [RS_AsPNG](../api/sql/Raster-Output/RS_AsPNG.md) | PNG | Image format,
unsigned integer pixel types only |
```sql
-SELECT RS_AsArcGrid(raster)
+SELECT RS_AsGeoTiff(rast) AS raster_binary FROM rasterDf
```
-### As GeoTiff
+### Step 2: Write to files
-Use [RS_AsGeoTiff](../api/sql/Raster-writer.md#rs_asgeotiff) to get the binary
Dataframe of the raster in GeoTiff format.
+Use Sedona's built-in `raster` data source to write the binary DataFrame:
-```sql
-SELECT RS_AsGeoTiff(raster)
-```
+=== "Scala"
+ ```scala
+ rasterDf.withColumn("raster_binary", expr("RS_AsGeoTiff(rast)"))
+ .write.format("raster").mode("overwrite").save("my_raster_file")
+ ```
-### As Cloud Optimized GeoTiff
+=== "Python"
+ ```python
+ rasterDf.withColumn("raster_binary",
expr("RS_AsGeoTiff(rast)")).write.format(
+ "raster"
+ ).mode("overwrite").save("my_raster_file")
+ ```
-Use [RS_AsCOG](../api/sql/Raster-writer.md#rs_ascog) to get the binary
Dataframe of the raster in [Cloud Optimized GeoTiff](https://www.cogeo.org/)
(COG) format. COG is ideal for cloud-hosted raster data because it supports
efficient range-read access over HTTP.
+The writer data source options are:
-```sql
-SELECT RS_AsCOG(raster)
-```
+| Option | Default | Description |
+| :--- | :--- | :--- |
+| `rasterField` | The `binary` type column | The name of the binary column to
write. Required if the DataFrame has multiple binary columns. |
+| `fileExtension` | `.tiff` | File extension for output files (e.g., `.png`,
`.asc`). |
+| `pathField` | None | Column name containing the output file paths. If not
set, each file gets a random UUID name. |
+| `useDirectCommitter` | `true` | If `true`, files are written directly to the
target location. If `false`, files are written to a temp location first.
Writing with `false` is slower, especially on object stores like S3. |
-### As PNG
+Example with all options:
-Use [RS_AsPNG](../api/sql/Raster-writer.md#rs_aspng) to get the binary
Dataframe of the raster in PNG format.
+=== "Scala"
+ ```scala
+ rasterDf.withColumn("raster_binary", expr("RS_AsGeoTiff(rast)"))
+ .write.format("raster")
+ .option("rasterField", "raster_binary")
+ .option("pathField", "path")
+ .option("fileExtension", ".tiff")
+ .mode("overwrite")
+ .save("my_raster_file")
Review Comment:
This example sets `.option("pathField", "path")`, but earlier in the
tutorial the GeoTiff `raster` data source output columns are `rast`, `x`, `y`,
and `name` (no `path`). As written, this snippet will fail unless the user
created a `path` column; consider using `name` (or show how to derive a
`path`/filename column) so the example is copy/paste runnable.
##########
docs/api/sql/Raster-Output/RS_AsCOG.md:
##########
@@ -0,0 +1,85 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ -->
+
+# RS_AsCOG
+
+Introduction: Returns a binary DataFrame from a Raster DataFrame. Each raster
object in the resulting DataFrame is a [Cloud Optimized
GeoTIFF](https://www.cogeo.org/) (COG) image in binary format. COG is a GeoTIFF
that is internally organized to enable efficient range-read access over HTTP,
making it ideal for cloud-hosted raster data.
Review Comment:
The introduction says this function returns a “binary DataFrame from a
Raster DataFrame”, but `RS_AsCOG` is a scalar expression that returns a binary
value/byte array per row. Reword to describe the per-row return value rather
than implying it returns a DataFrame.
```suggestion
Introduction: For each input raster, returns a binary [Cloud Optimized
GeoTIFF](https://www.cogeo.org/) (COG) representation. When applied to a Raster
DataFrame, this produces a binary column where each value is a COG image in
binary format. COG is a GeoTIFF that is internally organized to enable
efficient range-read access over HTTP, making it ideal for cloud-hosted raster
data.
```
##########
docs/api/sql/Raster-Operators/RS_AsRaster.md:
##########
@@ -0,0 +1,116 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ -->
+
+# RS_AsRaster
+
+Introduction: `RS_AsRaster` converts a vector geometry into a raster dataset
by assigning a specified value to all pixels covered by the geometry. Unlike
`RS_Clip`, which extracts a subset of an existing raster while preserving its
original values, `RS_AsRaster` generates a new raster where the geometry is
rasterized onto a raster grid. The function supports all geometry types and
takes the following parameters:
+
+* `geom`: The geometry to be rasterized.
+* `raster`: The reference raster to be used for overlaying the `geom` on.
+* `pixelType`: Defines data type of the output raster. This can be one of the
following, D (double), F (float), I (integer), S (short), US (unsigned short)
or B (byte).
+* `allTouched` (Since: `v1.7.1`): Decides the pixel selection criteria. If set
to `true`, the function selects all pixels touched by the geometry, else,
selects only pixels whose centroids intersect the geometry. Defaults to `false`.
+* `value`: The value to be used for assigning pixels covered by the geometry.
Defaults to using `1.0` if not provided.
+* `noDataValue`: Used for assigning the no data value of the resultant raster.
Defaults to `null` if not provided.
+* `useGeometryExtent`: Defines the extent of the resultant raster. When set to
`true`, it corresponds to the extent of `geom`, and when set to false, it
corresponds to the extent of `raster`. Default value is `true` if not set.
+
+Format:
+
+```
+RS_AsRaster(geom: Geometry, raster: Raster, pixelType: String, allTouched:
Boolean, value: Double, noDataValue: Double, useGeometryExtent: Boolean)
+```
+
+```
+RS_AsRaster(geom: Geometry, raster: Raster, pixelType: String, allTouched:
Boolean, value: Double, noDataValue: Double)
+```
+
+```
+RS_AsRaster(geom: Geometry, raster: Raster, pixelType: String, allTouched:
Boolean, value: Double)
+```
+
+```
+RS_AsRaster(geom: Geometry, raster: Raster, pixelType: String, allTouched:
Boolean)
+```
+
+```
+RS_AsRaster(geom: Geometry, raster: Raster, pixelType: String)
+```
+
+Return type: `Raster`
+
+Since: `v1.5.0`
+
+!!!note
+ The function doesn't support rasters that have any one of the following
properties:
+ ```
+ ScaleX < 0
+ ScaleY > 0
+ SkewX != 0
+ SkewY != 0
+ ```
+ If a raster is provided with anyone of these properties then
IllegalArgumentException is thrown.
Review Comment:
Grammar: “If a raster is provided with anyone of these properties then
IllegalArgumentException is thrown.” Consider changing to “any one of these
properties … then an IllegalArgumentException is thrown.”
```suggestion
If a raster is provided with any one of these properties, then an
IllegalArgumentException is thrown.
```
##########
docs/api/sql/Raster-Output/RS_AsArcGrid.md:
##########
@@ -0,0 +1,63 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ -->
+
+# RS_AsArcGrid
+
+Introduction: Returns a binary DataFrame from a Raster DataFrame. Each raster
object in the resulting DataFrame is an ArcGrid image in binary format. ArcGrid
only takes 1 source band. If your raster has multiple bands, you need to
specify which band you want to use as the source.
Review Comment:
The introduction says this function returns a “binary DataFrame from a
Raster DataFrame”, but `RS_AsArcGrid` is a scalar expression that returns a
binary value/byte array per row. Reword to describe the per-row return value
rather than implying it returns a DataFrame.
```suggestion
Introduction: Returns a binary value (byte array) representing an ArcGrid
image for each input raster. When used on a Raster DataFrame column, each
raster object in the resulting column is an ArcGrid image in binary format.
ArcGrid only takes 1 source band. If your raster has multiple bands, you need
to specify which band you want to use as the source.
```
##########
docs/tutorial/raster.md:
##########
@@ -503,47 +565,93 @@ Please refer to [Raster visualizer
docs](../api/sql/Raster-Functions.md#raster-o
## Save to permanent storage
-Sedona has APIs that can save an entire raster column to files in a specified
location. Before saving, the raster type column needs to be converted to a
binary format. Sedona provides several functions to convert a raster column
into a binary column suitable for file storage. Once in binary format, the
raster data can then be written to files on disk using the Sedona file storage
APIs.
-
-```sparksql
-rasterDf.write.format("raster").option("rasterField",
"raster").option("fileExtension",
".tiff").mode(SaveMode.Overwrite).save(dirPath)
-```
+Saving raster data is a two-step process: (1) convert the Raster column to
binary format using an `RS_AsXXX` function, and (2) write the binary DataFrame
to files using Sedona's `raster` data source writer.
-Sedona has a few writer functions that create the binary DataFrame necessary
for saving the raster images.
+### Step 1: Convert to binary format
-### As Arc Grid
+Choose one of the following output format functions:
-Use [RS_AsArcGrid](../api/sql/Raster-writer.md#rs_asarcgrid) to get the binary
Dataframe of the raster in Arc Grid format.
+| Function | Format | Description |
+| :--- | :--- | :--- |
+| [RS_AsGeoTiff](../api/sql/Raster-Output/RS_AsGeoTiff.md) | GeoTiff |
General-purpose raster format with optional compression |
+| [RS_AsCOG](../api/sql/Raster-Output/RS_AsCOG.md) | Cloud Optimized GeoTiff |
Ideal for cloud storage with efficient range-read access |
+| [RS_AsArcGrid](../api/sql/Raster-Output/RS_AsArcGrid.md) | Arc Grid |
ASCII-based format, single band only |
+| [RS_AsPNG](../api/sql/Raster-Output/RS_AsPNG.md) | PNG | Image format,
unsigned integer pixel types only |
```sql
-SELECT RS_AsArcGrid(raster)
+SELECT RS_AsGeoTiff(rast) AS raster_binary FROM rasterDf
```
-### As GeoTiff
+### Step 2: Write to files
-Use [RS_AsGeoTiff](../api/sql/Raster-writer.md#rs_asgeotiff) to get the binary
Dataframe of the raster in GeoTiff format.
+Use Sedona's built-in `raster` data source to write the binary DataFrame:
-```sql
-SELECT RS_AsGeoTiff(raster)
-```
+=== "Scala"
+ ```scala
+ rasterDf.withColumn("raster_binary", expr("RS_AsGeoTiff(rast)"))
+ .write.format("raster").mode("overwrite").save("my_raster_file")
+ ```
-### As Cloud Optimized GeoTiff
+=== "Python"
+ ```python
+ rasterDf.withColumn("raster_binary",
expr("RS_AsGeoTiff(rast)")).write.format(
+ "raster"
+ ).mode("overwrite").save("my_raster_file")
+ ```
-Use [RS_AsCOG](../api/sql/Raster-writer.md#rs_ascog) to get the binary
Dataframe of the raster in [Cloud Optimized GeoTiff](https://www.cogeo.org/)
(COG) format. COG is ideal for cloud-hosted raster data because it supports
efficient range-read access over HTTP.
+The writer data source options are:
-```sql
-SELECT RS_AsCOG(raster)
-```
+| Option | Default | Description |
+| :--- | :--- | :--- |
+| `rasterField` | The `binary` type column | The name of the binary column to
write. Required if the DataFrame has multiple binary columns. |
Review Comment:
The `rasterField` row says it is “Required if the DataFrame has multiple
binary columns”, but the raster writer actually defaults to selecting a binary
column even when multiple are present (it picks the last binary field in the
schema). Consider rewording this to “recommended/strongly recommended” (or
document the selection rule) to match behavior.
```suggestion
| `rasterField` | The `binary` type column | The name of the binary column
to write. If not set, the writer uses the last `binary` column in the DataFrame
schema; when multiple binary columns are present, explicitly setting this
option is strongly recommended. |
```
##########
docs/api/sql/Raster-Output/RS_AsPNG.md:
##########
@@ -0,0 +1,62 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ -->
+
+# RS_AsPNG
+
+Introduction: Returns a PNG byte array, that can be written to raster files as
PNGs using the Sedona raster data source writer. This function can only accept
pixel data type of unsigned integer. PNG can accept 1 or 3 bands of data from
the raster, refer to [RS_Band](../Raster-Band-Accessors/RS_Band.md) for more
details.
Review Comment:
The introduction implies `RS_AsPNG` returns a DataFrame, but it actually
returns a binary value/byte array per row (usable as a binary column). Reword
the introduction to avoid implying a DataFrame return.
```suggestion
Introduction: For each input raster row, returns a PNG byte array (binary
value) that can be stored in a binary column or written to raster files as PNGs
using the Sedona raster data source writer. This function can only accept pixel
data type of unsigned integer. PNG can accept 1 or 3 bands of data from the
raster, refer to [RS_Band](../Raster-Band-Accessors/RS_Band.md) for more
details.
```
##########
docs/api/sql/Raster-Output/RS_AsGeoTiff.md:
##########
@@ -0,0 +1,65 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ -->
+
+# RS_AsGeoTiff
+
+Introduction: Returns a binary DataFrame from a Raster DataFrame. Each raster
object in the resulting DataFrame is a GeoTiff image in binary format.
Review Comment:
The introduction says this function returns a “binary DataFrame from a
Raster DataFrame”, but `RS_AsGeoTiff` is a scalar expression that returns a
binary value/byte array per row (usable as a binary column). Reword to describe
the per-row return value rather than implying it returns a DataFrame.
```suggestion
Introduction: Returns a binary value (byte array) for each input raster,
where each value is the corresponding raster encoded as a GeoTiff image in
binary format.
```
##########
docs/tutorial/raster.md:
##########
@@ -560,11 +668,7 @@ The raster objects are represented as `SedonaRaster`
objects in Python, which ca
```
```python
-df_raster = (
- sedona.read.format("binaryFile")
- .load("/path/to/raster.tif")
- .selectExpr("RS_FromGeoTiff(content) as rast")
-)
+df_raster = sedona.read.format("raster").load("/path/to/raster.tif")
rows = df_raster.collect()
raster = rows[0].rast
raster # <sedona.raster.sedona_raster.InDbSedonaRaster at 0x1618fb1f0>
Review Comment:
`sedona.read.format("raster")` defaults to `retile=true`, so collecting and
using `rows[0].rast` will typically give a single tile, not the full raster.
Consider showing `.option("retile", "false")` (or an aggregation step) so the
example reliably returns one raster per file.
##########
docs/api/sql/Raster-Functions.md:
##########
@@ -197,3 +198,7 @@ These functions convert raster data to various output
formats for visualization.
| [RS_AsBase64](Raster-Output/RS_AsBase64.md) | String | Returns a base64
encoded string of the given raster. If the datatype is integral then this
function internally takes the first 4 bands as RGBA, and converts them to the
PNG format, finally produces... | v1.5.0 |
| [RS_AsImage](Raster-Output/RS_AsImage.md) | String | Returns a HTML that
when rendered using an HTML viewer or via a Jupyter Notebook, displays the
raster as a square image of side length `imageWidth`. Optionally, an imageWidth
parameter can be passe... | v1.5.0 |
| [RS_AsMatrix](Raster-Output/RS_AsMatrix.md) | String | Returns a string,
that when printed, outputs the raster band as a pretty printed 2D matrix. All
the values of the raster are cast to double for the string. RS_AsMatrix allows
specifying the number ... | |
+| [RS_AsArcGrid](Raster-Output/RS_AsArcGrid.md) | Binary | Returns a binary
DataFrame from a Raster DataFrame. Each raster object is an ArcGrid image in
binary format. | v1.4.1 |
+| [RS_AsGeoTiff](Raster-Output/RS_AsGeoTiff.md) | Binary | Returns a binary
DataFrame from a Raster DataFrame. Each raster object is a GeoTiff image in
binary format. | v1.4.1 |
Review Comment:
In the Raster Output table, several entries say “Returns a binary DataFrame
from a Raster DataFrame”, but these `RS_As*` functions return a binary value
(byte array) per row. Please adjust the table descriptions to reflect the
per-row return value (consistent with the “Return type: Binary” shown on the
function pages).
```suggestion
| [RS_AsArcGrid](Raster-Output/RS_AsArcGrid.md) | Binary | Returns a binary
value (byte array) for each raster row, where each value encodes the raster as
an ArcGrid image in binary format. | v1.4.1 |
| [RS_AsGeoTiff](Raster-Output/RS_AsGeoTiff.md) | Binary | Returns a binary
value (byte array) for each raster row, where each value encodes the raster as
a GeoTiff image in binary format. | v1.4.1 |
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
