rmagick4j 0.3.4-java → 0.3.9-java

data/lib/rmagick4j/constants.rb

@@ -0,0 +1,34 @@
+module Magick
+  Effects = Java::Magick4jEffects
+  Magick4J = Java::magick4j
+  RMagick4J = Java::rmagick4j
+
+
+  QuantumDepth = 8
+  QuantumRange = 2**QuantumDepth-1
+  QuantumScale = 1.0/QuantumRange.to_f
+  
+  # Geometries
+  JGeometry        = Magick4J::Geometry
+
+  JRelativeHeightDistance = Magick4J::RelativeHeightDistance
+  JRelativeWidthDistance = Magick4J::RelativeWidthDistance
+  
+  JHeightDistances = [
+                      Magick4J::SimpleValueHeightDistance,
+                      Magick4J::PercentValueHeightDistance,
+                      Magick4J::AspectValueHeightDistance,
+                      Magick4J::LessValueHeightDistance,
+                      Magick4J::GreaterValueHeightDistance,
+                      Magick4J::AreaValueHeightDistance
+                     ]
+
+  JWidthDistances = [
+                      Magick4J::SimpleValueWidthDistance,
+                      Magick4J::PercentValueWidthDistance,
+                      Magick4J::AspectValueWidthDistance,
+                      Magick4J::LessValueWidthDistance,
+                      Magick4J::GreaterValueWidthDistance,
+                      Magick4J::AreaValueWidthDistance
+                     ]
+end

data/lib/rmagick4j/draw.rb

@@ -0,0 +1,124 @@
+
+module Magick
+  class Draw
+
+    def annotate(img, width, height, x, y, text, &add)
+      instance_eval &add if add
+      text = parse_string(text)
+      @draw.annotate(img._image, width, height, x, y, text)
+      self
+    end
+    
+    def clone
+      b = Draw.new
+      b.primitives = @primitives.clone
+      b._draw = @draw.clone
+      b.freeze if self.frozen?
+      b
+    end
+
+    def draw(image)
+      @draw.clone.draw(image._image, Magick4J.CommandParser.parse(@primitives))
+      self
+    end
+
+    def fill= fill
+      @draw.fill = Magick4J.ColorDatabase.query_default(fill)
+      self
+    end
+
+    def font_family= font_family
+      @draw.font_family = font_family
+      self
+    end
+
+    def font_weight= font_weight
+      font_weight = {BoldWeight => 700, NormalWeight => 400}[font_weight]
+      @draw.font_weight = font_weight
+    end
+
+    def get_multiline_type_metrics(*args)
+      raise ArgumentError.new('wrong number of arguments (#{args.length})') if not (1..2) === args.length
+      string = parse_string(args.last)
+      image = args.first._image if args.length == 2
+      type_metrics_from_java(@draw.getMultilineTypeMetrics(string, image))
+    end
+    
+    def get_type_metrics(*args)
+      raise ArgumentError.new('wrong number of arguments (#{args.length})') if not (1..2) === args.length
+      string = parse_string(args.last)
+      image = args.first._image if args.length == 2
+      type_metrics_from_java(@draw.getTypeMetrics(string, image))
+    end
+
+    def font= font
+      # TODO
+    end
+
+    def gravity= gravity
+      @draw.setGravity(gravity._val)
+    end
+
+    def initialize
+      # Docs say that you can initialize with a block, but it doesn't really work because it inits an ImageInfo not a DrawInfo.
+      # instance_eval &add if add
+      @draw = Magick4J::DrawInfo.new
+      @primitives = ''
+    end
+
+    def inspect
+      if @primitives == ''
+        '(no primitives defined)'
+      else
+        @primitives
+      end
+    end
+
+    def pointsize= pointsize
+      @draw.setPointSize(pointsize)
+    end
+
+    def primitive primitive
+      # TODO Concat in a string like they do, then use helper to parse later
+      @primitives << "\n" unless @primitives.empty?
+      @primitives << primitive.gsub(/[\r|\n]/, '')
+      self
+    end
+
+    def rotation= rotation
+      @draw.rotate(rotation)
+      self
+    end
+
+    def stroke= stroke
+      @draw.setStroke(Magick4J.ColorDatabase.queryDefault(stroke))
+      self
+    end
+
+    private
+    
+    def parse_string(text)
+      text.split(/\\n/).join("\n")
+    end
+    
+    def type_metrics_from_java(jmetrics)
+      metrics = TypeMetric.new
+      metrics.ascent = jmetrics.getAscent
+      metrics.descent = jmetrics.getDescent
+      metrics.height = jmetrics.getHeight
+      metrics.max_advance = jmetrics.getMaxAdvance
+      metrics.width = jmetrics.getWidth
+      metrics
+    end
+    
+    protected
+    
+    def primitives=(value)
+      @primitives = value.to_str
+    end
+    
+    def _draw=(value)
+      @draw = value
+    end
+  end
+end

data/lib/rmagick4j/enum.rb

@@ -0,0 +1,120 @@
+
+module Magick
+  
+  class Enum
+
+    def self.def_val(name, val)
+      enum = new(name, val)
+      Magick.const_set(name, enum)
+    end
+
+    def initialize(name, val)
+      @name = name
+      @val = val
+    end
+
+    def to_i
+      @val.ordinal
+    end
+
+    def _val
+      @val
+    end
+
+  end
+  
+  # Enums
+
+  class CompositeOperator < Enum
+    def_val :CopyOpacityCompositeOp, Magick4J.CompositeOperator::COPY_OPACITY
+    def_val :OverCompositeOp, Magick4J.CompositeOperator::OVER
+  end
+
+  class GravityType < Enum
+    def_val :CenterGravity, Magick4J.Gravity::CENTER
+    def_val :EastGravity, Magick4J.Gravity::EAST
+    def_val :ForgetGravity, Magick4J.Gravity::FORGET
+    def_val :NorthEastGravity, Magick4J.Gravity::NORTH_EAST
+    def_val :NorthGravity, Magick4J.Gravity::NORTH
+    def_val :NorthWestGravity, Magick4J.Gravity::NORTH_WEST
+    def_val :SouthEastGravity, Magick4J.Gravity::SOUTH_EAST
+    def_val :SouthGravity, Magick4J.Gravity::SOUTH
+    def_val :SouthWestGravity, Magick4J.Gravity::SOUTH_WEST
+    def_val :WestGravity, Magick4J.Gravity::WEST
+  end
+
+  class ColorspaceType < Enum
+    def_val :GRAYColorspace, Magick4J.Colorspace::GRAY
+    def_val :RGBColorspace, Magick4J.Colorspace::RGB
+    def_val :UndefinedColorspace, Magick4J.Colorspace::Undefined
+  end
+
+
+  # Simple hack Enums.
+  # TODO All these need changed to the official way used above.
+
+  @@enumVal = 1
+  def self.nextVal
+    @@enumVal = @@enumVal + 1
+  end
+
+  LeftAlign = nextVal
+  RightAlign = nextVal
+  CenterAlign = nextVal
+  StartAnchor = nextVal
+  MiddleAnchor = nextVal
+  EndAnchor = nextVal
+  NoDecoration = nextVal
+  UnderlineDecoration = nextVal
+  OverlineDecoration = nextVal
+  LineThroughDecoration = nextVal
+
+  AnyWeight = nextVal
+  NormalWeight = nextVal
+  BoldWeight = nextVal
+  BolderWeight = nextVal
+  LighterWeight = nextVal
+
+  PointMethod = nextVal
+  ReplaceMethod = nextVal
+  FloodfillMethod = nextVal
+  FillToBorderMethod = nextVal
+  ResetMethod = nextVal
+  NormalStretch = nextVal
+  UltraCondensedStretch = nextVal
+  ExtraCondensedStretch = nextVal
+  CondensedStretch = nextVal
+  SemiCondensedStretch = nextVal
+  SemiExpandedStretch = nextVal
+  ExpandedStretch = nextVal
+  ExtraExpandedStretch = nextVal
+  UltraExpandedStretch = nextVal
+  AnyStretch = nextVal
+  NormalStyle = nextVal
+  ItalicStyle = nextVal
+  ObliqueStyle = nextVal
+  AnyStyle = nextVal
+
+  # ColorspaceType constants
+  # DEF_ENUM(ColorspaceType)
+  TransparentColorspace = nextVal
+  OHTAColorspace = nextVal
+  XYZColorspace = nextVal
+  YCbCrColorspace = nextVal
+  YCCColorspace = nextVal
+  YIQColorspace = nextVal
+  YPbPrColorspace = nextVal
+  YUVColorspace = nextVal
+  CMYKColorspace = nextVal
+  SRGBColorspace = nextVal
+  HSLColorspace = nextVal
+  HWBColorspace = nextVal
+  HSBColorspace = nextVal           # IM 6.0.0
+  CineonLogRGBColorspace = nextVal  # GM 1.2
+  LABColorspace = nextVal           # GM 1.2
+  Rec601LumaColorspace = nextVal    # GM 1.2 && IM 6.2.2
+  Rec601YCbCrColorspace = nextVal   # GM 1.2 && IM 6.2.2
+  Rec709LumaColorspace = nextVal    # GM 1.2 && IM 6.2.2
+  Rec709YCbCrColorspace = nextVal   # GM 1.2 && IM 6.2.2
+  LogColorspace = nextVal           # IM 6.2.3
+end

data/lib/rmagick4j/gradient_fill.rb

@@ -0,0 +1,14 @@
+
+module Magick
+  class GradientFill
+
+    def fill(image)
+      @fill.fill(image._image)
+    end
+
+    def initialize(x1, y1, x2, y2, start_color, end_color)
+      @fill = Magick4J.GradientFill.new(x1, y1, x2, y2, Magick4J.ColorDatabase.queryDefault(start_color), Magick4J.ColorDatabase.queryDefault(end_color))
+    end
+
+  end
+end

data/lib/rmagick4j/image.rb

@@ -0,0 +1,351 @@
+module Magick
+  class Image
+    
+    def self.from_blob(blob, &add)
+      # TODO multiple images in file
+      [Image.from_image(Magick4J.MagickImage.from_blob(blob.to_java_bytes), &add)]
+    end
+
+    def self.read(file, &add)
+      info = Info.new(&add)
+      image = Magick4J.ImageDatabase.createDefault(file.to_s, info._info) || Magick4J.MagickImage.new(java.io.File.new(file.to_s))
+      [Image.from_image(image,&add)]
+    end
+    
+    def self.from_image(image, &add)
+      raise ArgumentError, 'First parameter must be a MagickImage instance.' unless image.is_a? Magick4J.MagickImage
+      magick_image = Image.new(image.getWidth(), image.getHeight(), &add)
+      magick_image._image = image
+      magick_image
+    end
+    
+    def self.allocate(*args, &add)
+      info = Info.new(&add)
+      if args.length == 1
+        case args[0]
+        when String then
+          # TODO Respect Dir.getwd
+          name = args[0]
+          @image = Magick4J.ImageDatabase.createDefault(name, info._info) || Magick4J.MagickImage.new(java.io.File.new(name))
+        when Magick4J.MagickImage then
+          @image = args[0]
+        when Image then
+          @image = args[0]._image
+        else
+          raise ArgumentError, "The argument just can be a String, a MagickImage or an Image instance."
+        end
+      else
+        @image = Magick4J.MagickImage.new(args[0], args[1], info._info)
+        if args.length == 3
+          args[2].fill(self)
+        end
+      end
+    end
+
+    def background_color
+      @image.getBackgroundColor
+    end
+    
+    def background_color=(value)
+      raise TypeError, "argument must be color name or pixel (#{value.class} given)" unless value.is_a?(String) || value.is_a?(Pixel)
+      value = Pixel.from_color(value) if value.is_a?(String)
+      @image.setBackgroundColor(value)
+    end
+
+    def blur
+      @image.getBlur
+    end
+    
+    def blur=(value)
+      raise TypeError, "no implicit conversion to float from #{value.class.to_s.downcase}" unless value.is_a? Numeric
+      @image.setBlur(value)
+    end
+
+    def blur_image(radius=0.0, sigma=1.0)
+      # Swap order on purpose. I wanted them the other way around in Magick4J.
+      Image.from_image(Effects.BlurEffect.new(radius,sigma).apply(_image))
+    end
+    
+    def change_geometry(geometry)
+      geometry = Geometry.from_s(geometry.to_s) unless geometry.is_a? Geometry
+      index = if geometry.flag.nil?
+                0
+              else
+                geometry.flag._val
+              end
+      width_distance = geometry.width.nil? ? 
+        JRelativeWidthDistance.new : 
+        JWidthDistances[index].new(geometry.width)
+      height_distance = geometry.height.nil? ? 
+        JRelativeHeightDistance.new : 
+        JHeightDistances[index].new(geometry.height)
+      geometry = JGeometry.new(width_distance, height_distance, 
+                               geometry.x, geometry.y)      
+      yield geometry.calculate_width(self._image),
+            geometry.calculate_height(self._image),
+            self
+    end
+
+    def charcoal(radius=0.0, sigma=1.0)
+      Image.from_image(Effects.CharcoalEffect.new(radius,sigma).apply(_image))
+    end
+
+    def columns
+      @image.getWidth
+    end
+
+    def composite(*args)
+      # image, x, y, composite_op
+      args[0] = args[0]._image
+      args.map! {|arg| arg.is_a?(Enum) ? arg._val : arg}
+      Image.from_image(@image.composited(*args))
+    end
+
+    def copy
+      Image.from_image(@image.clone)
+    end
+
+    def crop(*args)
+      copy.crop!(*args)
+    end
+
+    def crop!(*args)
+      # gravity, x, y, width, height, reset_offset
+      # Defaults.
+      gravity = nil
+      x = y = -1
+      reset_offset = false
+      # Find available args.
+      if args.first.is_a? GravityType
+        gravity = args.shift._val
+      end
+      if [FalseClass, TrueClass].member? args.last.class
+        reset = args.pop
+      end
+      if args.length == 4
+        x, y = args[0..1]
+      end
+      width, height = args[-2..-1]
+      # Call Java.
+      # TODO Why wouldn't we reset offset information? Do we need to use that?
+      @image =  unless gravity.nil?
+                  if x == -1 || y == -1
+                    @image.crop(gravity, width, height)
+                  else
+                    @image.crop(gravity, x, y, width, height)
+                  end
+                else
+                  @image.crop(x,y,width,height)
+                end
+      self
+    end
+
+    def display
+      @image.display
+      self
+    end
+
+    def edge(radius=0.0)
+      Image.from_image(Effects.EdgeEffect.new(radius).apply(_image))
+    end
+
+    def erase!
+      @image.erase
+    end
+
+    def format
+      @image.getFormat
+    end
+
+    def format= format
+      @image.setFormat(format)
+      self
+    end
+
+    def flip
+      copy.flip
+    end
+
+    def flip!
+      @image.flip
+      self
+    end
+
+    def _image
+      @image
+    end
+    
+    def _image=(new_image)
+      @image = new_image
+    end
+
+    def implode(amount=0.5)
+      Image.from_image(Effects.ImplodeEffect.new(amount).apply(_image))
+    end
+    
+    def _info
+      @info
+    end
+    
+    def _info=(new_info)
+      @info = new_info
+    end
+
+    def initialize(columns, rows, fill=nil, &info_block)
+      info = Info.new(&info_block)
+      @image = Magick4J.MagickImage.new(columns, rows, info._info)
+      fill.fill(self) if fill.respond_to? :fill
+    end
+
+    def matte
+      @image.getMatte
+    end
+
+    def matte= matte
+      @image.setMatte(matte)
+    end
+
+    def negate(grayscale=false)
+      Image.from_image(Effects.NegateEffect.new(grayscale).apply(_image))
+    end
+
+    def normalize
+      Image.from_image(Effects.NormalizeEffect.new().apply(_image))
+    end
+
+    def quantize(number_colors=256, colorspace=RGBColorspace, dither=true, tree_depth=0, measure_error=false)
+      Image.from_image(@image.quantized(number_colors, colorspace._val, dither, tree_depth, measure_error))
+    end
+
+    def raise(width=6, height=6, raise=true)
+      Image.from_image(@image.raised(width, height, raise))
+    end
+
+		def remap
+			# TODO: Implement. Just here to avoid warning in RMagick 2.9 file.
+		end
+
+    def resize(*args)
+      copy.resize!(*args)
+    end
+
+    def resize!(*args)
+      @image =  if args.length == 1
+                  @image.resized(args[0])
+                elsif args.length == 2 # It must be 4 nor 2, but two of them are not yet implemented
+                  # TODO  Implement the other two arguments.
+                  # arg[0] --> new_width
+                  # arg[1] --> new_height
+                  # arg[2] --> filter=LanczosFilter
+                  # arg[3] --> support=1.0
+                  @image.resized(args[0],args[1])
+                else
+                  Kernel.raise ArgumentError, "wrong number of parameters(#{args.length} for 1 or 4)"
+                end
+      self
+    end
+
+    def rotate(amount, qualifier=nil)
+      copy.rotate!(amount,qualifier)
+    end
+
+    def rotate!(amount, qualifier=nil)
+      if qualifier == '<' && columns < rows
+        @image.rotate(amount)
+        self
+      elsif qualifier == '>' && columns > rows
+        @image.rotate(amount)
+        self
+      elsif qualifier.nil?
+        @image.rotate(amount)
+        self
+      else
+        nil
+      end
+    end
+
+    def rows
+      @image.getHeight
+    end
+
+    def shade(shading=false,azimuth=30,elevation=30)
+      Image.from_image(Effects.ShadeEffect.new(shading,azimuth,elevation).apply(_image))
+    end
+    
+    def solarize(threshold=50)
+      Image.from_image(Effects.SolarizeEffect.new(threshold).apply(_image))
+    end
+
+    def store_pixels(x, y, columns, rows, pixels)
+      ria_size = columns*rows
+      raise IndexError, "not enough elements in array - expecting #{ria_size}, got #{pixels.size}" if pixels.size < ria_size
+      @image.storePixels(x,y,columns,rows,pixels.to_java)
+    end
+
+    def to_blob(&add)
+      info = Info.new(&add)
+      @image.setFormat(info.format) if info.format
+      String.from_java_bytes(@image.toBlob)
+    end
+
+    def watermark(mark, lightness=1.0, saturation=1.0, gravity=nil, x_offset=0, y_offset=0)
+      if gravity.is_a? Numeric
+        # gravity is technically an optional argument in the middle.
+        gravity = nil
+        y_offset = x_offset
+        x_offset = gravity
+      end
+      # TODO Perform watermark.
+      self
+    end
+
+    def wave(amplitude=25.0, wavelength=150.0)
+      Image.from_image(Effects.WaveEffect.new(amplitude,wavelength).apply(_image))
+    end
+
+    def write(file, &add)
+      # TODO I'm having trouble finding out how this info is used, so I'll skip using it for now.
+      info = Info.new(&add)
+      # TODO Resolve pwd as needed
+      @image.write(file)
+      self
+    end
+
+    def file_type(file)
+      @image.file_type(file)
+    end
+
+    def file_path(file)
+      @image.file_path(file)
+    end
+
+    class Info
+
+      # TODO Replace with call to Java, or is this the better way? Should it be converted to the Java version only later?
+      def background_color= background_color
+        @info.setBackgroundColor(Magick4J.ColorDatabase.queryDefault(background_color))
+      end
+
+      attr_accessor :format
+
+      def _info
+        @info
+      end
+
+      def initialize(&add)
+        @info = Magick4J.ImageInfo.new
+        instance_eval &add if add
+      end
+
+      def size= size
+        size = Geometry.from_s(size) if size.is_a? String
+        geometry = Magick4J.Geometry.new
+        geometry.setWidth(size.width)
+        geometry.setHeight(size.height)
+        @info.setSize(geometry)
+      end
+
+    end
+
+  end
+end