def syntheticEM(fillLineIndices, width, height, lineValue, backgroundValue, rois=None, sigma=1.4, noise=False, noise_sd=25.0, show=False): ip = FloatProcessor(width, height) pixels = ip.getPixels() # Fill background Arrays.fill(pixels, backgroundValue) # Paint black horizontal line for i in fillLineIndices: Arrays.fill(pixels, i * width, (i + 1) * height, lineValue) if rois: ip.setColor(lineValue) for roi in rois: ip.draw(roi) # Blur GaussianBlur().blurFloat(ip, 0, sigma, 0.02) if noise: ip.noise(noise_sd) ip.setMinAndMax(0, 255) imp = ImagePlus("synth", ip) if show: imp.show() return imp
def test_zeros(self): if self.type is None: return array = jarray.zeros(2, self.type) self.assertValueEqual(len(array), 2) self.assertValueEqual(array[0], self.default_value) self.assertValueEqual(array[1], self.default_value) array[0] = self.instance self.assertValueEqual(array[0], self.instance) with self.assertRaises(TypeError): array[0] = self.bad_instance Arrays.fill(array, self.instance) self.assertValueEqual(array[0], self.instance) self.assertValueEqual(array[1], self.instance) self.assertRaises(TypeError, jarray.zeros, None)
def unpackBits2(bytes_packedbits, tags, use_imagereader=False): # Decompress a packBits-compressed image, returns an array of n_bytes. # ra: a RandomAccessFile with the pointer at the right place to start reading. # PackBits actually packages bytes: a byte-wise RLE most efficient at encoding runs of bytes # 3 types of data packets: # 1. two-byte encoded run packet: # - first byte is the number of bytes in the run. # Ranges from -127 to -1, meaning +1: from 2 to 128 (-count + 1) # - second byte value of each byte in the run. # 2. literal run packet: stores 1 to 128 bytes literally without compression. # - first byte is the number of bytes in the run. # Ranges from 0 to 127, indicating 1 to 128 values (count + 1) # - then the sequence of literal bytes # 3. no-op packet: never used, value -128. # See documentation: http://paulbourke.net/dataformats/tiff/tiff_summary.pdf # (note documentation PDF has its details flipped when it comes to the ranges for literal runs and packed runs) # See also: ij.io.ImageReader.packBitsUncompress (a public method without side effects) n_bytes = tags["width"] * tags["height"] if use_imagereader: return ImageReader(FileInfo()).packBitsUncompress( bytes_packedbits, n_bytes) bytes = zeros(n_bytes, 'b') try: indexP = 0 # packed indexU = 0 # unpacked while indexU < n_bytes: count = bytes_packedbits[indexP] if count >= 0: # Literal run System.arraycopy(bytes_packedbits, indexP + 1, bytes, indexU, count + 1) indexP += count + 2 # one extra for the 'count' byte indexU += count + 1 else: # Packed run Arrays.fill(bytes, indexU, indexU - count + 1, bytes_packedbits[indexP + 1]) indexP += 2 indexU += -count + 1 except: print sys.exc_info() finally: return bytes
def unpackBits(ra, tags, use_imagereader=False): # Decompress a packBits-compressed image, write into bytes array starting at indexU. # ra: a RandomAccessFile with the pointer at the right place to start reading. # PackBits actually packages bytes: a byte-wise RLE most efficient at encoding runs of bytes # 3 types of data packets: # 1. two-byte encoded run packet: # - first byte is the number of bytes in the run. # Ranges from -127 to -1, meaning +1: from 2 to 128 (-count + 1) # - second byte value of each byte in the run. # 2. literal run packet: stores 1 to 128 bytes literally without compression. # - first byte is the number of bytes in the run. # Ranges from 0 to 127, indicating 1 to 128 values (count + 1) # - then the sequence of literal bytes # 3. no-op packet: never used, value -128. # See documentation: http://paulbourke.net/dataformats/tiff/tiff_summary.pdf # (note documentation PDF has its details flipped when it comes to the ranges for literal runs and packed runs) # See also: ij.io.ImageReader.packBitsUncompress (a public method without side effects) if use_imagereader: return ImageReader(FileInfo()).packBitsUncompress( getIFDImageBytes(ra, tags), tags["width"] * tags["height"]) try: bytes = zeros(tags["width"] * tags["height"], 'b') indexU = 0 # index over unpacked bytes for strip_offset, strip_length in zip(tags["StripOffsets"], tags["StripByteCounts"]): ra.seek(strip_offset) indexP = 0 while indexP < strip_length and indexU < len(bytes): count = ra.readByte() if count >= 0: # Literal run ra.read(bytes, indexU, count + 1) indexP += count + 2 # one extra for the count byte indexU += count + 1 else: # Packed run Arrays.fill(bytes, indexU, indexU - count + 1, ra.readByte()) indexP += 2 indexU += -count + 1 except: print sys.exc_info() finally: return bytes
dp[0] = 0 for money in range(1, amount+1): res = amount + 1 for coin in coins: if money >= coin and dp[money-coin] != amount+1: res = min(dp[money-coin]+1, res) dp[money] = res if dp[amount] == amount + 1: return -1 return dp[amount] class Solution { public int coinChange(int[] coins, int amount) { if (amount < 1) return 0; int[] dp = new int[amount + 1]; Arrays.fill(dp, Integer.MAX_VALUE); dp[0] = 0; for (int coin : coins) { for (int i = coin; i <= amount; i++) { if (dp[i - coin] != Integer.MAX_VALUE) { dp[i] = Math.min(dp[i], dp[i - coin] + 1); } } } return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount]; } } class Solution { public int coinChange(int[] coins, int amount) { int[] dp = new int[amount+1];