diff --git a/src/main/java/azgracompress/io/loader/BasicLoader.java b/src/main/java/azgracompress/io/loader/BasicLoader.java index e3a5979f530a23ba6472962a4ba8820631873333..244386bf095d1a4ee17c0056a34acea4cd056da0 100644 --- a/src/main/java/azgracompress/io/loader/BasicLoader.java +++ b/src/main/java/azgracompress/io/loader/BasicLoader.java @@ -2,12 +2,15 @@ package azgracompress.io.loader; import azgracompress.data.*; +import javax.print.attribute.standard.RequestingUserName; import java.io.IOException; public abstract class BasicLoader { protected final V3i dims; protected int threadCount = 1; + private DataWrappingStrategy wrappingStrategy = DataWrappingStrategy.MirroredRepeat; + protected BasicLoader(final V3i datasetDims) { this.dims = datasetDims; } @@ -16,6 +19,16 @@ public abstract class BasicLoader { return dims; } + + public DataWrappingStrategy getWrappingStrategy() { + return wrappingStrategy; + } + + public void setWrappingStrategy(DataWrappingStrategy strategy) { + wrappingStrategy = strategy; + } + + /** * Abstract method to load specified plane data. * @@ -123,16 +136,60 @@ public abstract class BasicLoader { return blocks; } + private void loadBlock(final int[] block, final int planeIndex, final int blockXOffset, final int blockYOffset, final V2i blockDim) { int srcX, srcY; for (int y = 0; y < blockDim.getY(); y++) { srcY = blockYOffset + y; - if (srcY >= dims.getY()) - break; + + // Row overflow + if (srcY >= dims.getY()) { + + if (wrappingStrategy == DataWrappingStrategy.LeaveBlank) + break; + + if (wrappingStrategy == DataWrappingStrategy.ClampToEdge) { + final int srcRow = dims.getY() - 1; + final int dstOffset = y * blockDim.getX(); + for (int x = 0; x < blockDim.getX(); x++) { + srcX = (blockXOffset + x); + if (srcX >= dims.getX()) + srcX = dims.getX() - 1; + block[dstOffset + x] = valueAt(planeIndex, Block.index(srcX, srcRow, dims.getX())); + } + continue; + } else if (wrappingStrategy == DataWrappingStrategy.MirroredRepeat) { + final int srcRow = dims.getY() - ((srcY - dims.getY()) + 1); + final int dstOffset = y * blockDim.getX(); + for (int x = 0; x < blockDim.getX(); x++) { + srcX = (blockXOffset + x); + if (srcX >= dims.getX()) + srcX = dims.getX() - 1; + block[dstOffset + x] = valueAt(planeIndex, Block.index(srcX, srcRow, dims.getX())); + } + continue; + } + } + for (int x = 0; x < blockDim.getX(); x++) { srcX = blockXOffset + x; - if (srcX >= dims.getX()) - break; + + // Column overflow. + if (srcX >= dims.getX()) { + + if (wrappingStrategy == DataWrappingStrategy.LeaveBlank) + break; + if (wrappingStrategy == DataWrappingStrategy.ClampToEdge) { + block[Block.index(x, y, blockDim.getX())] = valueAt(planeIndex, Block.index(dims.getX() - 1, srcY, dims.getX())); + continue; + } else if (wrappingStrategy == DataWrappingStrategy.MirroredRepeat) { + + block[Block.index(x, y, blockDim.getX())] = + valueAt(planeIndex, Block.index(dims.getX() - ((srcX - dims.getX()) + 1), srcY, dims.getX())); + continue; + } + + } block[Block.index(x, y, blockDim.getX())] = valueAt(planeIndex, Block.index(srcX, srcY, dims.getX())); } } @@ -142,8 +199,10 @@ public abstract class BasicLoader { int srcX, srcY; for (int y = 0; y < blockDim.getY(); y++) { srcY = blockYOffset + y; - if (srcY >= dims.getY()) - break; + if (srcY >= dims.getY()) { + // handleBlockRowOverflow(block, blockDim, y, srcY); + continue; + } for (int x = 0; x < blockDim.getX(); x++) { srcX = blockXOffset + x; if (srcX >= dims.getX()) diff --git a/src/main/java/azgracompress/io/loader/DataWrappingStrategy.java b/src/main/java/azgracompress/io/loader/DataWrappingStrategy.java new file mode 100644 index 0000000000000000000000000000000000000000..fc2015eaee2b5f7489c0ca4882212e19e9bcb71f --- /dev/null +++ b/src/main/java/azgracompress/io/loader/DataWrappingStrategy.java @@ -0,0 +1,19 @@ +package azgracompress.io.loader; + +/** + * What to do when blocks or voxels extend outside the source image. These parameters are based on OpenGL texture wrapping options. + */ +public enum DataWrappingStrategy { + /** + * Pixels outside the source range are left blank, value 0. + */ + LeaveBlank, + /** + * The edge value is repeated. + */ + ClampToEdge, + /** + * Pixels will be repeated by mirrored strategy. + */ + MirroredRepeat +} diff --git a/src/main/java/azgracompress/io/loader/IPlaneLoader.java b/src/main/java/azgracompress/io/loader/IPlaneLoader.java index e88a46951b7a69106d93b37c5f77c4ee8a57c359..5db29c5eeb5e0e133848aa896f002de1b8c383be 100644 --- a/src/main/java/azgracompress/io/loader/IPlaneLoader.java +++ b/src/main/java/azgracompress/io/loader/IPlaneLoader.java @@ -22,6 +22,20 @@ public interface IPlaneLoader { return false; } + /** + * Get data wrapping strategy configured for this loader. + * + * @return Wrapping strategy. + */ + DataWrappingStrategy getWrappingStrategy(); + + /** + * Configure data wrapping strategy for this loader. + * + * @param strategy Wrapping strategy. + */ + void setWrappingStrategy(DataWrappingStrategy strategy); + /** * Get dimensions of the image, for which the loader was created. *