Merge pull request #18 from tlnagy/tn/package-rename

Rename from TIFF -> TiffImages

Author: tlnagy

Project.toml

@@ -1,7 +1,7 @@
-name = "TIFF"
+name = "TiffImages"
 uuid = "731e570b-9d59-4bfa-96dc-6df516fadf69"
 authors = ["Tamas Nagy <[email protected]>"]
-version = "0.1.1"
+version = "0.2.0"
 
 [deps]
 ColorTypes = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
@@ -15,10 +15,4 @@ PkgVersion = "eebad327-c553-4316-9ea0-9fa01ccd7688"
 ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
 
 [compat]
-julia = "1.4"
-
-[extras]
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-
-[targets]
-test = ["Test"]
+julia = "1.4, 1.5"

README.md

@@ -1,21 +1,21 @@
-# 💎 TIFF.jl
+# 💎 TiffImages.jl
 
 | **Documentation**                 | **Build Status**                                              |
 |:----------------------------------|:--------------------------------------------------------------|
 | [![][docs-dev-img]][docs-dev-url] | [![][status-img]][status-url] [![][travis-img]][travis-url] [![][codecov-img]][codecov-url] |
 
-This package aims to be a fast, minimal, and correct TIFF reader and writer written in Julia. 
+This package aims to be a fast, minimal, and correct TIFF reader and writer written in Julia.
 
 This is a WIP. Be warned. Here be🐉.
 
 [docs-dev-img]: https://img.shields.io/badge/docs-dev-blue.svg
-[docs-dev-url]: https://tamasnagy.com/TIFF.jl/dev
+[docs-dev-url]: https://tamasnagy.com/TiffImages.jl/dev
 
-[travis-img]: https://travis-ci.com/tlnagy/TIFF.jl.svg?branch=master
-[travis-url]: https://travis-ci.com/tlnagy/TIFF.jl
+[travis-img]: https://travis-ci.com/tlnagy/TiffImages.jl.svg?branch=master
+[travis-url]: https://travis-ci.com/tlnagy/TiffImages.jl
 
-[codecov-img]: https://codecov.io/gh/tlnagy/TIFF.jl/branch/master/graph/badge.svg
-[codecov-url]: https://codecov.io/gh/tlnagy/TIFF.jl
+[codecov-img]: https://codecov.io/gh/tlnagy/TiffImages.jl/branch/master/graph/badge.svg
+[codecov-url]: https://codecov.io/gh/tlnagy/TiffImages.jl
 
 [status-img]: https://www.repostatus.org/badges/latest/wip.svg
 [status-url]: https://www.repostatus.org/#wip

docs/make.jl

@@ -1,5 +1,5 @@
 using Documenter
-using TIFF
+using TiffImages
 
 using Literate
 using Images
@@ -12,13 +12,13 @@ for ex in EXAMPLES
     Literate.markdown(ex, OUTPUT, documenter = true)
 end
 
-DocMeta.setdocmeta!(TIFF, :DocTestSetup, :(using TIFF); recursive=true)
+DocMeta.setdocmeta!(TiffImages, :DocTestSetup, :(using TiffImages); recursive=true)
 makedocs(
     format = Documenter.HTML(
-        prettyurls = true, 
+        prettyurls = true,
     ),
-    modules=[TIFF], 
-    sitename="TIFF.jl",
+    modules=[TiffImages],
+    sitename="TiffImages.jl",
     authors="Tamas Nagy and contributors",
     pages = [
         "Home" => "index.md",
@@ -37,5 +37,5 @@ makedocs(
 )
 
 deploydocs(
-    repo = "github.com/tlnagy/TIFF.jl.git",
+    repo = "github.com/tlnagy/TiffImages.jl.git",
 )

docs/src/contributing.md

@@ -7,12 +7,12 @@ the community in identifying edge cases.
 
 There is incredible diversity in the TIFF ecosystem so much so that there is a
 backronym "Thousand Incompatible File Formats" to describe it. I have tried to
-establish a good baseline test set of TIFFs that should guarantee that `TIFF.jl`
+establish a good baseline test set of TIFFs that should guarantee that `TiffImages.jl`
 should "just work tm" for most people, but if you have a TIFF that you run into
-that breaks `TIFF.jl` please do the following:
+that breaks `TiffImages.jl` please do the following:
 
-1. create a pull request against the 
+1. create a pull request against the
    [example TIFF](https://github.com/tlnagy/exampletiffs) repo adding the file.
    The smaller the file, the better.
 2. update the README table with license information, etc.
-3. Open an issue against `TIFF.jl` with the error message and the expected result
+3. Open an issue against `TiffImages.jl` with the error message and the expected result

docs/src/index.md

@@ -1,4 +1,4 @@
-# TIFF.jl
+# TiffImages.jl
 
 *Pure-Julia TIFF reader and writer with a focus on correctness* 🧐
 
@@ -16,7 +16,7 @@ do as much lazily and flexibly as possible.
 
 ## Features
 
-TIFF.jl supports:
+TiffImages.jl supports:
 
 - [x] The TIFF 6.0 baseline spec
 - [x] Thorough testing

docs/src/lib/extend/index.md

@@ -1,8 +1,8 @@
-# Extending TIFF.jl
+# Extending TiffImages.jl
 
-If you want to extend `TIFF.jl` to add support for more features or change how
+If you want to extend `TiffImages.jl` to add support for more features or change how
 TIFF data is loaded, you have come to right place.
 
 ```@docs
-TIFF.Tag
+TiffImages.Tag
 ```

docs/src/lib/extend/tags.md

@@ -1,5 +1,5 @@
 # Built-in Tags
 
 ```@docs
-TIFF.TiffTag
+TiffImages.TiffTag
 ```

examples/writing.jl

@@ -1,6 +1,6 @@
 # # Writing TIFFs
 
-# This page is a tutorial for saving TIFFs using TIFF.jl and covers some common
+# This page is a tutorial for saving TIFFs using TiffImages.jl and covers some common
 # use cases
 
 #md # ```@contents
@@ -9,7 +9,7 @@
 #md # ```
 
 # You might want to write TIFFs to disk too. Now this can be done quite simply
-# with TIFF.jl. Say you have some AbstractArray type that you want to save, here
+# with TiffImages.jl. Say you have some AbstractArray type that you want to save, here
 # we'll call it `data`:
 
 using Random
@@ -19,21 +19,21 @@ Random.seed!(123)
 data = rand(RGB{N0f8}, 10, 10)
 
 #md # !!! note
-#md #     TIFF.jl only works with AbstractArrays with `eltype`s of `<:Colorant` because
+#md #     TiffImages.jl only works with AbstractArrays with `eltype`s of `<:Colorant` because
 #md #     the writer needs to know how to represent the image data on disk. Make sure to
 #md #     convert your `AbstractArrays` using before passing them. See the
 #md #     [common strategies](#Strategies-for-saving-common-types) section
 #md #     below for tips.
-     
-# ## Converting to `TIFF.jl`'s TIFF type
+
+# ## Converting to `TiffImages.jl`'s TIFF type
 # Next lets convert `data` to a TIFF type
 
-using TIFF
-img = TIFF.DenseTaggedImage(data)
+using TiffImages
+img = TiffImages.DenseTaggedImage(data)
 
 # Wait nothing happened! Hang with me, lets take a closer look at our new object
 # using the `dump` command. We can see that there's now new information
-# associated with our data! TIFF.jl usually represents TIFF images as simply the
+# associated with our data! TiffImages.jl usually represents TIFF images as simply the
 # data and associated tags that describe the data
 
 dump(img; maxdepth=1)
@@ -54,26 +54,26 @@ ifd
 # These are some of the most basic tags that are required by the TIFF spec. We
 # can even update it to add our own custom tags
 
-ifd[TIFF.IMAGEDESCRIPTION] = "This is very important data"
+ifd[TiffImages.IMAGEDESCRIPTION] = "This is very important data"
 ifd
 
 # We can even add tags that aren't in the standard set in
-# [`TIFF.TiffTag`](@ref) as long as they are a `UInt16`
+# [`TiffImages.TiffTag`](@ref) as long as they are a `UInt16`
 
 ifd[UInt16(34735)] = UInt16[1, 2, 3]
 ifd
 
 # We can also delete tags if we decide we don't want them:
 
-delete!(ifd, TIFF.IMAGEDESCRIPTION)
+delete!(ifd, TiffImages.IMAGEDESCRIPTION)
 ifd
 
 #md # !!! warning
-#md #     Careful with `delete!`, if any of core tags are deleted, TIFF.jl and
+#md #     Careful with `delete!`, if any of core tags are deleted, TiffImages.jl and
 #md #     other readers might fail to read the file
 
 # ## Saving to disk
-# 
+#
 # Once you're happy with your TIFF object, you can write it to disk as follows:
 
 open("test.tif", "w") do io
@@ -82,32 +82,32 @@ end
 
 # And to just double check, we can load it right back in
 
-TIFF.load("test.tif")
+TiffImages.load("test.tif")
 
 # ## Strategies for saving common types
 
 # The general strategy for saving arrays will differ a bit depending on the
 # type. The key step is the convert or reinterpret the arrays so that the
 # elements are subtypes of `Colors.Colorant`
 
-# #### Unsigned Integers 
+# #### Unsigned Integers
 
 # Say you want to save a 3D array of small integers as grayscale values.
 
 data2 = rand(UInt8.(1:255), 5, 10)
 eltype(data2)
 
-# You can't directly save the `data2` since TIFF.jl needs some color information
+# You can't directly save the `data2` since TiffImages.jl needs some color information
 # to properly save the file. You can use
 # [`reinterpret`](https://docs.julialang.org/en/v1/base/arrays/#Base.reinterpret)
 # to accomplish this:
 
 grays = reinterpret(Gray{N0f8}, data2)
-img2 = TIFF.DenseTaggedImage(grays)
+img2 = TiffImages.DenseTaggedImage(grays)
 
 # Here the data are first reinterpreted as `N0f8`s, which is a
 # [`FixedPointNumber`](https://github.com/JuliaMath/FixedPointNumbers.jl) then
-# wrapped with a Gray type that marks this as a grayscale image. TIFF.jl uses
+# wrapped with a Gray type that marks this as a grayscale image. TiffImages.jl uses
 # this information to update the TIFF tags
 
 # #### Floating point numbers
@@ -117,7 +117,7 @@ img2 = TIFF.DenseTaggedImage(grays)
 
 data = rand(Float64, 3, 5, 10);
 colors = dropdims(reinterpret(RGB{eltype(data)}, data), dims=1) # drop first dimension
-img3 = TIFF.DenseTaggedImage(colors)
+img3 = TiffImages.DenseTaggedImage(colors)
 
 # Here we dropped the first dimension since it was collapsed into the RGB type
 # when we ran the `reinterpret` command.
@@ -131,7 +131,7 @@ img3 = TIFF.DenseTaggedImage(colors)
 
 data = rand(-100:100, 5, 5)
 #--------------------------
-img4 = TIFF.DenseTaggedImage(reinterpret(Gray{Q0f63}, data))
+img4 = TiffImages.DenseTaggedImage(reinterpret(Gray{Q0f63}, data))
 println(img4.ifds[1])
 
 # As you can see the `SAMPLEFORMATS` and `BITSPERSAMPLE` tags correctly updated

src/TIFF.jl renamed to src/TiffImages.jl

@@ -1,4 +1,4 @@
-module TIFF
+module TiffImages
 
 using ColorTypes
 using DocStringExtensions

src/compression.jl

@@ -24,7 +24,7 @@ function Base.read!(tf::TiffFile, arr::AbstractArray{T, N}, ::Val{COMPRESSION_PA
             arr[pos:(pos-n)] .= nxt[1]
             pos += -n
         end
-        pos += 1 
+        pos += 1
     end
 end
 
@@ -34,19 +34,19 @@ end
 Given a `read!` signature, returns the compression technique implemented.
 
 ```jldoctest
-julia> TIFF.get_inflator(first(methods(read!, [TIFF.TiffFile, AbstractArray, Val{TIFF.COMPRESSION_NONE}], [TIFF])).sig)
-COMPRESSION_NONE::CompressionType = 1 
+julia> TiffImages.get_inflator(first(methods(read!, [TiffImages.TiffFile, AbstractArray, Val{TiffImages.COMPRESSION_NONE}], [TiffImages])).sig)
+COMPRESSION_NONE::CompressionType = 1
 ```
 """
 get_inflator(::Type{Tuple{typeof(read!), TiffFile, AbstractArray{T, N} where {T, N}, Val{C}}}) where C = C
 
 # autogenerate nice error messages for all non-implemented inflation methods
 implemented = map(x->get_inflator(x.sig), methods(read!, [TiffFile, AbstractArray, Val], ))
-comps = Set(instances(TIFF.CompressionType))
+comps = Set(instances(CompressionType))
 setdiff!(comps, implemented)
 
 for comp in comps
     eval(quote
-        Base.read!(tf::TiffFile, arr::AbstractArray, ::Val{$comp}) = error("Compression ", $comp, " is not implemented. Please open an issue against TIFF.jl.")
+        Base.read!(tf::TiffFile, arr::AbstractArray, ::Val{$comp}) = error("Compression ", $comp, " is not implemented. Please open an issue against TiffImages.jl.")
     end)
 end

src/files.jl

@@ -35,7 +35,7 @@ Base.read(io::IOStream, t::Type{TiffFile}) = read(Stream(format"TIFF", io, extra
 
 function Base.write(file::TiffFile{O}) where O
     seekstart(file.io)
-    
+
     if ENDIAN_BOM == 0x04030201 #little endian
         write(file.io, "II")
     else
@@ -85,18 +85,18 @@ function Base.read!(file::TiffFile, arr::AbstractArray)
 end
 
 function Base.read!(io::IOStream, arr::SubArray{T,N,P,I,L}) where {T, N, P <: BitArray, I <: Tuple{UnitRange, Int64}, L}
-    error("Strided bilevel TIFFs are not yet supported. Please open an issue against TIFF.jl.")
+    error("Strided bilevel TIFFs are not yet supported. Please open an issue against TiffImages.jl.")
 end
 
 function Base.read!(file::TiffFile, arr::BitArray)
-    Bc = arr.chunks 
+    Bc = arr.chunks
     n = length(arr)
     nc = length(read!(file.io, Bc))
     if length(Bc) > 0 && Bc[end] & Base._msk_end(n) ≠ Bc[end]
         Bc[end] &= Base._msk_end(n) # ensure that the BitArray is not broken
     end
     for i in 1:nc
-       Bc[i] = TIFF.reversebits(Bc[i]) 
+       Bc[i] = reversebits(Bc[i])
     end
     arr
 end

src/utils.jl

@@ -45,18 +45,18 @@ const _mask4_uint128 = (UInt128(0x0f0f0f0f0f0f0f0f) << 64) | UInt128(0x0f0f0f0f0
 
 Reverse the bit order in each byte of `x`. Julia assumes the first bit of each
 byte is packed as a 0x01, while in TIFFs it's actually packed as 0x80. This
-function flips the bit packing order. 
+function flips the bit packing order.
 
 !!! note
     This function does not flip the byte packing order, a la `bswap`.
 
 This function should be applied to a BitArray after it is read in via
-[`reversebits!`](@ref). 
+[`reversebits!`](@ref).
 
 Code adapted from https://github.com/JuliaLang/julia/pull/34791
 
 ```jldoctest
-julia> TIFF.reversebits(0x0101) == 0x8080
+julia> TiffImages.reversebits(0x0101) == 0x8080
 true
 ```
 """