12
anonymous No title
Ruby
n-oouchi:~/environment $ irb
2.5.1 :001 > puts 'Hello\nWorld'
Hello\nWorld
 => nil 
2.5.1 :002 > puts "Hello\nWorld"
Hello
World
 => nil 
anonymous No title
Ruby
// 秀丸マクロ
// 差分チェック.mac
// UTF-8(BOM付き)で保存してください
// 編集中のファイルと選択したファイルの変更箇所のチェック
// 行の追加や削除には未対応 (´・ω・`)

// ファイル選択
readonlyopenfile "/h .\\*.txt";
#hwnd_f1 = hidemaruhandle(0);
$f1=filename;
if ($f1==""){endmacro;}
setactivehidemaru 1;
closehidemaruforced #hwnd_f1;

// クリップボードで先頭の空行が跳ばされる問題の防止対策
gofiletop;insert "a";selectall;copy;escape;undo;#hwnd1=hidemaruhandle(0);
run "rubyw -x "+currentmacrofilename+" "+$f1;
endmacro;

/*
#! ruby
# encoding: utf-8

# ruby のインストール
# rubyインストーラーを使って ruby をインストール
# rubyinstaller-devkit-2.65-1-x64.exeを実行(ファイル名は例)

# gem でライブラリをインストール
# コマンドラインから 
# gem install win32-clipboard
# gem install diff-lcs

# 文字コード
Encoding.default_external = 'UTF-8'

# 標準出力とエラーの出力(デバッグ用)
# $stdout=open("tmp.txt","w")
# $stderr=open("err.txt","w")

# 秀丸のインストールパス
hide="C:/Program Files (x86)/Hidemaru/Hidemaru.exe"

require 'win32/clipboard'
require 'diff/lcs'

st=Win32::Clipboard.data(Win32::Clipboard::UNICODETEXT).sub(/^a/,"").gsub("\r\n","\n")
File.write("diff.txt",st)

file1="diff.txt"
file2=ARGV[0].encode(Encoding::UTF_8)

ar1=open(file1).read.split("\n")
ar2=open(file2).read.split("\n")

#x:列 y:行 r:right l:文字長さ mp:文字列(+) mm:文字列(-)
ar3,ar4,x,y,x0,r,l,mp,mm=[],[],0,0,0,0,0,"",""
(0..ar1.size).each{|i|
  if ar1[i]!=ar2[i]
    begin
      sdiffs = Diff::LCS.sdiff(ar1[i],ar2[i])
    end
    next unless sdiffs
    sdiffs.each_with_index{|f,j|
      if f.new_element != f.old_element
        new=(f.new_element=="\\" ? "\\\\" : f.new_element)
        ar3<<[i,j,f.new_position,new,f.old_element]
      end}
  end}

ar3.each{|e|
  print "e=";p e
  if e[0]==y #同一行
    if e[1]<=x+1 #文字が連続
      x+=1
      l+=1 if e[4]
      mp+=e[3].to_s
      mm+=e[4].to_s
    else #文字が非連続
      ar4<<[y,x0,l,mp,mm]
      x,x0,mp,mm=e[1],e[2],e[3].to_s,e[4].to_s
      l=(e[4] ? 1 :0)
    end
  else #行が変わると
    ar4<<[y,x0,l,mp,mm]
    x,y,x0,mp,mm=e[1],e[0],e[1],e[3].to_s,e[4].to_s
    l=(e[4] ? 1 :0)
  end  }
ar4<<[y,x0,l,mp,mm]
#ar4.map{|e| print "ar4=";p e}


# 秀丸マクロ作成
mac=File.expand_path("tmp.mac")
macro=open(mac,"w")
macro.print "\uFEFF"
macro.puts %|
setcompatiblemode 0x20030;
selectall;
colormarker 0x000000, 0xc2c79e, 11, 1;
escape;begingroupundo;disabledraw;\n|
ar4.each{|e|
  if (e[3]=="" && e[4]!="") # 文字削除 #e[2]=>l  e[3]=>mp e[4]=>mm
    macro.puts %Q|moveto2 0,#{e[0]+1};right #{e[1]};beginsel;right #{e[2]};delete;backspace;undo;|
  elsif (e[3]!="" && e[4]!="") #文字変更
    macro.puts %Q|moveto2 0,#{e[0]+1};right #{e[1]};beginsel;right #{e[2]};insert "#{e[3]}";|
  elsif e[3]!="" #文字追加
    macro.puts %Q|moveto2 0,#{e[0]+1};right #{e[1]};insert "#{e[3]}";|
  end}
macro.puts %|
endgroupundo;gofiletop;enabledraw;goupdatedown;endmacro;\n|

# マクロ実行
spawn(%Q|"#{hide}" /fu8 /x "#{mac}" "#{file1}"|)
__END__
*/
anonymous sfpc#013タイム集計
Ruby
class Problem
  attr_accessor *(?a..?z).to_a.map(&:to_sym)
  def initialize
    @n = DATA.gets.to_s.to_i
    @a = Array.new(n){ DATA.gets.to_s.split }
  end

  def solve
    ans = []
    a.each do |rec|
      no,name,ante,post = rec
      sec = tosec(post) - tosec(ante)
      ans << [sec,name]
    end
    ans.sort
  end

  def tosec(timestring)
    h,m,s = timestring.split(/:/).map(&:to_i)
    h * 3600 + m * 60 + s
  end

  def tostr(sec)
    s = sec % 60
    sec /= 60
    m = sec % 60
    h = sec / 60
    sprintf("%02d:%02d:%02d", h, m, s)
  end

  def show(ans)
    ans.each do |sec,name|
      puts [name, tostr(sec)].join(" ")
    end
  end
end

Problem.new.instance_eval do
  show(solve)
end

__END__
11
2	ShuHONDA	6:57:10	19:02:42
3	okakita	6:24:27	26:26:49
4	loveflower	16:57:23	26:30:35
5	yanai	16:50:39	167:55:28
6	KanaeTsukimitsu	785:25:57	791:21:04
7	yuichiyoshida	784:50:55	791:25:27
8	RinkaSasagawa	808:39:17	813:30:26
9	yukakawamoto	808:33:10	814:56:46
10	takanoyuto	808:47:50	816:38:30
11	deltazarashi	808:49:58	817:47:40
12	NakatsukaMomoka	808:40:10	818:07:22
anonymous No title
Ruby
require "json"

class Problem
  attr_accessor :a
  def initialize
    @a = JSON.parse(gets)
  end

  def solve
    a.each_with_object(Hash.new(0)) do |record, ans|
      ans[record["result"]] += 1
    end
  end

  def show(ans)
    ans.each do |key,value|
      puts "#{key}: #{value}"
    end
  end
end

Problem.new.instance_eval do
  show(solve)
end
anonymous No title
Ruby
# Build environment suide
# [catapult\-server/BUILDWIN\.md at conanbuild · nemtech/catapult\-server](https://github.com/nemtech/catapult-server/blob/conanbuild/docs/BUILDWIN.md)
#
FROM ubuntu:18.04
# WORKDIR /tmp

RUN sed -i.bak -e "s%http://[^ ]\+%http://linux.yz.yamagata-u.ac.jp/ubuntu/%g" /etc/apt/sources.list
RUN apt-get update -y && apt-get upgrade -y && apt-get install -y --no-install-recommends \
  git \
  curl \
  python3 \
  python3-pip \
  python3-setuptools \
  pkg-config \
  ninja-build \
  build-essential \
  libssl-dev \
  && apt-get clean && rm -rf /var/lib/apt/lists/*

# RUN apt-get update -y && apt-get upgrade -y && apt-get clean && apt-get install -y --no-install-recommends \
#   vim \
#   git \
#   curl \
#   autoconf \
#   automake \
#   apt-file \
#   software-properties-common \
#   pkg-config \
#   python3 \
#   python3-pip \
#   python3-setuptools \
#   ninja-build \
#   libc6-dev \
#   libgtest-dev \
#   libsasl2-dev \
#   libtool \
#   && apt-get clean && rm -rf /var/lib/apt/lists/*

# CMake (at least 3.14)
#  && ./bootstrap --prefix=/usr/local && make -j$(nproc) && make install \
RUN git clone https://gitlab.kitware.com/cmake/cmake.git -b v3.18.1 --depth 1 \
  && cd cmake \
  && ./bootstrap && make -j$(nproc) && make install \
  && cd -

# Conan
RUN pip3 install wheel \
  && pip3 install conan \
  && conan remote add nemtech https://api.bintray.com/conan/nemtech/symbol-server-dependencies
  # && conan config init \
  # && conan profile update settings.compiler.libcxx=libstdc++11 default \
  # && conan remote list

# catapult-server
RUN git clone https://github.com/nemtech/catapult-server.git -b main --depth 1 \
  && cd catapult-server \
  && mkdir _build && cd _build \
  && conan install .. --build=missing \
  && cmake -DUSE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -G Ninja .. \
  && ninja publish && ninja -j$(nproc)
anonymous No title
Ruby
@REM jww 外部変形
@REM 円外消去.BAT
@REM ruby 1.8.1 以降に対応
@REM 文字列を処理
@REM SJIS で保存してください
@echo off
REM #jww
REM #cd
REM #ht10
REM #ht20
REM #ht40
REM #zz
goto %1
REM #hm【円外消去】 |円外消去|等倍複写|2倍複写|N倍複写|回転複写|基準指示|
REM #:1
REM #h2
REM #hc  【円外消去】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【円外消去】円を指示
REM #e
REM #:2
REM #h2
REM #hc  【等倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【等倍複写】円を指示
REM #0%d 【等倍複写】複写先指示
REM #e
REM #:3
REM #h2
REM #hc  【2倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【2倍複写】円を指示
REM #0%d 【2倍複写】複写先指示
REM #e
REM #:4
REM #h2
REM #hc  【N倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【N倍複写】円を指示
REM #0%d 【N倍複写】複写先指示
REM #c   【N倍複写】倍率指定(無指定:1) : /_N
REM #e
REM #:5
REM #h2
REM #hc  【回転複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【回転複写】円を指示
REM #0%d 【回転複写】複写先指示
REM #c   【回転複写】倍率指定(無指定:1) : /_N
REM #e
REM #:6
REM #h2
REM #hc  【基準指示】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【基準指示】円を指示
REM #8ln 【基準指示】基準線を指示
REM #0%d 【基準指示】複写先指示
REM #c   【基準指示】倍率指定(無指定:1) : /_N
REM #e
  
:1
:2
:4
:5
:6
copy jwc_temp.txt jwc_bak.txt
rubyw -Ks -x %~f0 %1 %2
GOTO END
:3
copy jwc_temp.txt jwc_bak.txt
rubyw -Ks -x %~f0 %1 N2
GOTO END
  
【円外消去】指定した円の外側を消去
【等倍複写】指定した円の外側を消去して複写
【2倍複写】倍率2倍
【N倍複写】倍率N倍
【回転複写】意味はないけどランダムに回転させてみる
【基準指示】回転複写で基準線が水平になるように回転
  
#! ruby
# encoding: SJIS
  
# 座標値を取り込む際に円の中心からの相対座標に直す
# 座標値を出力する際
# 【円外消去】では座標を元に戻す
# 他は行列を使って倍率をかけたり回転させたり
  
include Math
require 'matrix'
  
$stdout=open("jwc_temp.txt","w")
$stderr=open("tmp_err.txt","w")
  
def kouten(a,c,b,d) #外積を使って二線(ab,cd)の交点を求める
  cp1=(d-b)[0]*(b-a)[1]-(d-b)[1]*(b-a)[0]
  cp2=(d-b)[0]*(c-b)[1]-(d-b)[1]*(c-b)[0]
  k=cp1/(cp1+cp2)
  p=(c-a)*k+a
end
  
class Vector #ruby 1.8.1対策
  def dot(a)
    self[0]*a[0]+self[1]*a[1]
  end
  def -@
    collect {|e| -e }
  end
  def /(x)
    els = @elements.collect{|e| e / x}
    self.class.elements(els, false)
  end
end
class Array
  def each_slice(num)
    arr=[]
    self.each_with_index{|e,i|
      arr[i/num]=[] unless arr[i/num]
      arr[i/num][i%num]=e}
    arr
  end
end
class String
  def each_char
    scan(/./){|c| yield(c)}
  end
  def bsize
    begin
      self.bytesize
    rescue
      self.size
    end
  end
end
  
opt=ARGV[0].to_i #1:【円外消去】
jwc=open("jwc_bak.txt").read
n=ARGV.grep(/^N/)[0].to_s.gsub(/^N/,"").to_f
n=1.0 if n==0
mx=Matrix[[n,0],[0,n]]
rd=(opt==5 ? rand(360.0) :0)
if opt==6 #【基準指示】
  ln8s,ln8e=jwc.match(/hhp8ln\n (-?[\d.]+) (-?[\d.]+) (-?[\d.]+) (-?[\d.]+)/m).
    to_a.map{|e| e.to_f}[1..4].each_slice(2).map{|e| Vector.elements(e)}
  ln8p=Vector.elements(jwc.match(/hp8ln (-?[\d.]+) (-?[\d.]+)/).
    to_a.map{|e| e.to_f}[1..2])
  ln8s,ln8e=ln8e,ln8s if (ln8p-ln8s).r>(ln8p-ln8e).r
  rd=-atan2((ln8e-ln8s)[1],(ln8e-ln8s)[0])*180.0/PI
end
mk=Matrix[[cos(rd*PI/180.0),-sin(rd*PI/180.0)],
  [sin(rd*PI/180.0),cos(rd*PI/180.0)]] #回転用行列
mx=mk*mx
vo=Vector[0,0]
  
cir=jwc.match(/hhp9ci\nci (-?[\d.]+) (-?[\d.]+) (-?[\d.]+)/m).
  to_a.map{|e| e.to_f}[1..3]
v0=Vector.elements(cir[0..1])
r1=cir[2]
hcw,hch,hcd,hcc=[],[],[],[]
fcw,fch,fcd,fcc=0,0,0,0
jwc.split("\n").each{|jw|
  if jw.match(/^hq/)
    puts "hd" if opt==1
  elsif jw.match(/^hc[whdc]/)
    hcw=jw.split(" ").map{|e| e.to_f} if /^hcw/=~jw
    hch=jw.split(" ").map{|e| e.to_f} if /^hch/=~jw
    hcd=jw.split(" ").map{|e| e.to_f} if /^hcd/=~jw
    hcc=jw.split(" ").map{|e| e.to_f} if /^hcc/=~jw
    puts jw
  elsif jw.match(/^cn0 (.*)/)
    fcw,fch,fcd,fcc=$1.split(" ").map{|e| e.to_f}
    puts jw
  elsif jw.match(/^cn([1-9]0?)/)
    cn=$1.to_i
    fcw,fch,fcd,fcc=hcw[cn],hch[cn],hcd[cn],hcc[cn]
    puts jw
  elsif jw.match(/^pt (.*)/) #点と点マーカの処理
    pp=$1.split(" ").map{|f| f.to_f}
    vp=Vector.elements([pp[0],pp[1]])
    vp=vp-v0
    if vp.r<r1
      vpn=(opt==1 ? vp+v0 : mx*vp)
      puts "pt "+vpn.to_a.join(" ") if pp.size==2 #点
      puts "pt "+vpn.to_a.join(" ")+" #{pp[2]*n} "+
        "#{(pp[3]+rd)%360.0} #{pp[4].to_i}" if pp.size==5 #点マーカ
    end
  elsif jw.match(/^( -?[\d.]+){4}/) #線の処理
    vs,ve=$&.split(" ").map{|e| e.to_f}.
      each_slice(2).map{|e| Vector.elements(e)}
    vs,ve=vs-v0,ve-v0
    vs,ve=ve,vs if vs.r>ve.r
    vb=Matrix[[0,-1],[1,0]]*(ve-vs) #90°回転
    vh=kouten(vo,vb,vs,ve) #円の中心から線への垂点
    if vh.r<r1
      vp=(ve-vs)*sqrt(r1**2-(vh.r)**2)/(ve-vs).r+vh
      vq=(vs-ve)*sqrt(r1**2-(vh.r)**2)/(ve-vs).r+vh
      vsn,ven,vpn,vqn=vs+v0,ve+v0,vp+v0,vq+v0 if opt==1
      vsn,ven,vpn,vqn=mx*vs,mx*ve,mx*vp,mx*vq if opt!=1
      if vs.r<r1 && ve.r<r1 #始点と終点が円内
        puts " "+(vsn.to_a+ven.to_a).join(" ")
      elsif vs.r<r1 #始点が円内
        puts " "+(vsn.to_a+vpn.to_a).join(" ")
      elsif (vq-vs).dot(ve-vs)>0 && (vp-vs).dot(ve-vs)>0 #円を横切る
        puts " "+(vqn.to_a+vpn.to_a).join(" ")
      end
    end
  elsif jw.match(/^ci (.*)/) #円の処理
    ci=$1.split(" ").map{|f| f.to_f}
    cc=Vector.elements(ci[0,2])
    cc=cc-v0                 #円弧中心
    r2=ci[2]                 #半径
    d=cc.r                   #円と円の距離
    ch=(ci[5] ? ci[5] :1.0)  #扁平率
    cj=(ci[6] ? ci[6] :0.0)  #軸角
    ccn=(opt==1 ? cc+v0 : mx*cc)
    if d>r1+r2 #円が離れている場合
      next
    elsif d<r1-r2 or (cc.r==0 && r1==r2)    #円の中に円がある又は円が同一
      if ci[3] #円弧か楕円
        puts "ci "+ccn.to_a.join(" ")+" #{r2*n} "+
          ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
      else
        puts "ci "+ccn.to_a.join(" ")+" #{r2*n}"
      end
    else #交点が存在する場合
      if ch<1.0 #楕円の場合はそのまま出力
        puts "ci "+ccn.to_a.join(" ")+" #{r2*n} "+
          ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
      else
        begin
          rad=acos((d**2+r1**2-r2**2)/(2*d*r1)) #余弦定理
        rescue
          next #(d**2+r1**2-r2**2)/(2*d*r1)が範囲外なら次へ
        end
        ma=Matrix[[cos(rad),sin(rad)],[-sin(rad),cos(rad)]]
        mb=Matrix[[cos(rad),-sin(rad)],[sin(rad),cos(rad)]]
        vp=ma*cc*(r1/d) #交点1
        vq=mb*cc*(r1/d) #交点2
        vc=Vector[r2,0]
        dp=atan2((vp-cc)[1],(vp-cc)[0])*180/PI
        dq=atan2((vq-cc)[1],(vq-cc)[0])*180/PI
        dp,dq=(dp+360.0)%360.0,(dq+360.0)%360.0
        dp,dq=[dp,dq].sort
        if ci.size==3 #円の場合
          dp,dq=dq,dp if (vc+cc).r<r1 #0°の点が円の外
          puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 #{rd}"
        else #円弧の場合
          ds,de=ci[3]+cj,ci[4]+cj #始角と終角
          de=(de-ds<0 ? de-ds+360.0 : de-ds)
          dp,dq=[dp,dq].map{|e| (e-ds+360.0)%360.0}.sort
          ms=Matrix[[cos(ds*PI/180),-sin(ds*PI/180)],[sin(ds*PI/180),cos(ds*PI/180)]]
          if dq<de #交点が2つ
            if (ms*vc+cc).r<r1 #始点が円内
              dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
              puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 #{rd}"
              puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dq} #{de} 1.0 #{rd}"
            else
              dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
              puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 #{rd}"
            end
          elsif dp<de #交点が1つ
            dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
            if (ms*vc+cc).r<r1 #始点が円内
              puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 #{rd}"
            else
              puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{de} 1.0 #{rd}"
            end
          else de<dp #円弧が円内
            dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
            if (ms*vc+cc).r<r1 #始点が円内
              puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{de} 1.0 #{rd}"
            end
          end
        end
      end
    end
  elsif jw.match(/^(c[hvsroptkz2])/) #文字列の処理
    #円の内外に関わらず文字列を削除したい場合は
    #次の行の先頭の#を削除してコメントアウトを解除する
    #next
    jch=jw.scan(/([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) (.*)$/).flatten
    vs,ve=jch[1..4].map{|e| e.to_f}.each_slice(2).map{|e| Vector.elements(e)}
    vs=vs-v0
    jc0,jc5=jch[0],jch[5][1..-1]
    vb=Matrix[[0,-1],[1,0]]*ve #90°回転
    vh=kouten(vo,vb,vs,vs+ve) #円の中心から線への垂点
    if vh.r<r1
      vp= ve*sqrt(r1**2-(vh.r)**2)/ve.r+vh
      vq=-ve*sqrt(r1**2-(vh.r)**2)/ve.r+vh
      dq,dp,jc5n=0,0,""
      if vs.r<r1 && (vs+ve).r<r1 #始点と終点が円内(q,s,e,p)
        jc5n=jc5
        vsn=vs
      elsif vs.r<r1 #始点が円内(q,s,p,e)
        jc5.each_char{|e|
          if (vp-vs).r>dp
            dp+=(e.bsize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
            jc5n+=e
          end}
        vsn=vs
      elsif (vs+ve).r<r1 #終点が円内(s,q,e,p)
        jc5.each_char{|e|
          if (vq-vs).r>dq
            dq+=(e.bsize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
          else
            jc5n+=e
          end}
        vsn=vs+ve*dq/(ve.r)
      elsif ve.dot(vq-vs)>0 && ve.dot(vp-vs)>0 #始点と終点が円を横切る(s,q,p,e)
        jc5.each_char{|e|
          if (vq-vs).r>dq
            dq+=(e.bsize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
            dp=dq
          elsif (vp-vs).r>dp
            dp+=(e.bsize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
            jc5n+=e
          end}
        vsn=vs+ve*dq/(ve.r)
      end
      if vsn #円外の文字は書き出さない
        vsn,ven=vsn+v0,mk*ve if opt==1
        vsn,ven=mx*vsn,mx*ve if opt!=1
        puts "cn0 #{fcw*n} #{fch*n} #{fcd*n} #{fcc.to_i}" unless n==1.0
        puts %Q|#{jc0} #{vsn[0]} #{vsn[1]} #{ven[0]} #{ven[1]} "#{jc5n}|
      end
    end
  else
    puts jw unless jw.match(/^s[lceog]/) #ソリッドデータは書き出さない
  end}
__END__
:END
anonymous No title
Ruby
@REM jww 外部変形
@REM 円外消去.BAT
@REM ruby 1.8.7 に対応
@REM 文字列を処理
@echo off
REM #jww
REM #cd
REM #ht10
REM #ht20
REM #ht40
REM #zz
goto %1
REM #hm【円外消去】 |円外消去|等倍複写|2倍複写|N倍複写|回転複写|
REM #:1
REM #h2
REM #hc  【円外消去】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【円外消去】円を指示
REM #e
REM #:2
REM #h2
REM #hc  【等倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【等倍複写】円を指示
REM #0%d 【等倍複写】複写先指示
REM #e
REM #:3
REM #h2
REM #hc  【2倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【2倍複写】円を指示
REM #0%d 【2倍複写】複写先指示
REM #e
REM #:4
REM #h2
REM #hc  【N倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【N倍複写】円を指示
REM #0%d 【N倍複写】複写先指示
REM #c   【N倍複写】倍率指定(無指定:1) : /_N
REM #e
REM #:5
REM #h2
REM #hc  【回転複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【回転複写】円を指示
REM #0%d 【回転複写】複写先指示
REM #c   【回転複写】倍率指定(無指定:1) : /_N
REM #e

:1
:2
:4
:5
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 %2
GOTO  END
:3
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 N2
GOTO  END

【円外消去】指定した円の外側を消去
【等倍複写】指定した円の外側を消去して複写
【2倍複写】倍率2倍
【N倍複写】倍率N倍
【回転複写】意味はないけどランダムに回転させてみる

#! ruby
# encoding: SJIS

# 座標値を取り込む際に円の中心からの相対座標に直す
# 座標値を出力する際
# 【円外消去】では座標を元に戻す
# 他は行列を使って倍率をかけたり回転させたり

include Math
require 'matrix'

$stdout=open("jwc_temp.txt","w")
$stderr=open("tmp_err.txt","w")

def kouten(a,c,b,d) #外積を使って二線(ab,cd)の交点を求める
	a=Vector.elements(a.to_a)
	b=Vector.elements(b.to_a)
	c=Vector.elements(c.to_a)
	d=Vector.elements(d.to_a)
	#cp1=(d-b).cross(b-a)[2]
	#cp2=(d-b).cross(c-b)[2]
	cp1=(d-b)[0]*(b-a)[1]-(d-b)[1]*(b-a)[0]
	cp2=(d-b)[0]*(c-b)[1]-(d-b)[1]*(c-b)[0]
	k=cp1/(cp1+cp2)
	p=(c-a)*k+a
end

class Vector
	def dot(a)
		self[0]*a[0]+self[1]*a[1]
	end
end

opt=ARGV[0].to_i #1:【円外消去】
jwc=open("jwc_bak.txt").read
n=ARGV.grep(/^N/)[0].to_s.gsub(/^N/,"").to_f
n=1.0 if n==0
mx=Matrix[[n,0],[0,n]]
rd=(opt==5 ? rand(360.0) :0)
mk=Matrix[[cos(rd*PI/180.0),-sin(rd*PI/180.0)],
	[sin(rd*PI/180.0),cos(rd*PI/180.0)]] #回転用行列
mx=mk*mx
vo=Vector[0,0]

cir=jwc.match(/hhp9ci\nci (-?[\d.]+) (-?[\d.]+) (-?[\d.]+)/m).
	to_a.map{|e| e.to_f}[1..3]
v0=Vector.elements(cir[0..1])
r1=cir[2]
hcw,hch,hcd,hcc=[],[],[],[]
fcw,fch,fcd,fcc=0,0,0,0
jwc.split("\n").each{|jw|
	if jw.match(/^hq/)
		puts "hd" if opt==1
	elsif jw.match(/^hc[whdc]/)
		hcw=jw.split(" ").map{|e| e.to_f} if /^hcw/=~jw
		hch=jw.split(" ").map{|e| e.to_f} if /^hch/=~jw
		hcd=jw.split(" ").map{|e| e.to_f} if /^hcd/=~jw
		hcc=jw.split(" ").map{|e| e.to_f} if /^hcc/=~jw
		puts jw
	elsif jw.match(/^cn0 (.*)/)
		fcw,fch,fcd,fcc=$1.split(" ").map{|e| e.to_f}
		puts jw
	elsif jw.match(/^cn([1-9]0?)/)
		cn=$1.to_i
		fcw,fch,fcd,fcc=hcw[cn],hch[cn],hcd[cn],hcc[cn]
		puts jw
	elsif jw.match(/^pt (.*)/) #点の処理
		vp=Vector.elements($1.split(" ").map{|f| f.to_f})
		vp=vp-v0
		if vp.r<r1
			vpn=(opt==1 ? vp+v0 : mx*vp)
			puts "pt "+vpn.to_a.join(" ")
		end
	elsif jw.match(/^( -?[\d.]+){4}/) #線の処理
		vs,ve=$&.split(" ").map{|e| e.to_f}.
			each_slice(2).map{|e| Vector.elements(e)}
		vs,ve=vs-v0,ve-v0
		vs,ve=ve,vs if vs.r>ve.r
		vb=Matrix[[0,-1],[1,0]]*(ve-vs) #90°回転
		vh=kouten(vo,vb,vs,ve) #円の中心から線への垂点
		if vh.r<r1
			vp=(ve-vs)*sqrt(r1**2-(vh.r)**2)*(1.0/(ve-vs).r)+vh
			vq=(vs-ve)*sqrt(r1**2-(vh.r)**2)*(1.0/(ve-vs).r)+vh
			if opt==1
				vsn,ven,vpn,vqn=vs+v0,ve+v0,vp+v0,vq+v0
			else
				vsn,ven,vpn,vqn=mx*vs,mx*ve,mx*vp,mx*vq
			end
			if vs.r<r1 && ve.r<r1 #始点と終点が円内
				puts " "+(vsn.to_a+ven.to_a).join(" ")
			elsif vs.r<r1 #始点が円内
				puts " "+(vsn.to_a+vpn.to_a).join(" ")
			elsif (vq-vs).dot(ve-vs)>0 && (vp-vs).dot(ve-vs)>0 #円を横切る
				puts " "+(vqn.to_a+vpn.to_a).join(" ")
			end
		end
	elsif jw.match(/^ci (.*)/) #円の処理
		ci=$1.split(" ").map{|f| f.to_f}
		cc=Vector.elements(ci[0,2])
		cc=cc-v0								#円弧中心
		r2=ci[2]								#半径
		d=cc.r									#円と円の距離
		ch=(ci[5] ? ci[5] :1.0)	#扁平率
		cj=(ci[6] ? ci[6] :0.0)	#軸角
		ccn=(opt==1 ? cc+v0 : mx*cc)
		if d>r1+r2 #円が離れている場合
			next
		elsif d<r1-r2 or (cc.r==0 && r1==r2)		#円の中に円がある又は円が同一
			if ci[3] #円弧か楕円
				puts "ci "+ccn.to_a.join(" ")+" #{r2*n} "+
					ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
			else
				puts "ci "+ccn.to_a.join(" ")+" #{r2*n}"
			end
		else #交点が存在する場合
			if ch<1.0 #楕円の場合はそのまま出力
				puts "ci "+ccn.to_a.join(" ")+" #{r2*n} "+
					ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
			else
				rad=acos((d**2+r1**2-r2**2)/(2*d*r1)) #余弦定理
				ma=Matrix[[cos(rad),sin(rad)],[-sin(rad),cos(rad)]]
				mb=Matrix[[cos(rad),-sin(rad)],[sin(rad),cos(rad)]]
				vp=ma*cc*(r1/d) #交点1
				vq=mb*cc*(r1/d) #交点2
				vc=Vector[r2,0]
				dp=atan2((vp-cc)[1],(vp-cc)[0])*180/PI
				dq=atan2((vq-cc)[1],(vq-cc)[0])*180/PI
				dp,dq=(dp+360.0)%360.0,(dq+360.0)%360.0
				dp,dq=[dp,dq].sort
				if ci.size==3 #円の場合
					dp,dq=dq,dp if (vc+cc).r<r1 #0°の点が円の外
					puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 #{rd}"
				else #円弧の場合
					ds,de=ci[3]+cj,ci[4]+cj #始角と終角
					de=(de-ds<0 ? de-ds+360.0 : de-ds)
					dp,dq=[dp,dq].map{|e| e-ds<0 ? e-ds+360.0 : e-ds}.sort
					ms=Matrix[[cos(ds*PI/180),-sin(ds*PI/180)],[sin(ds*PI/180),cos(ds*PI/180)]]
					if dq<de #交点が2つ
						if (ms*vc+cc).r<r1 #始点が円内
							dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 #{(cj+rd)%360.0}"
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dq} #{de} 1.0 #{(cj+rd)%360.0}"
						else
							dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 #{(cj+rd)%360.0}"
						end
					elsif dp<de #交点が1つ
						dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
						if (ms*vc+cc).r<r1 #始点が円内
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 #{(cj+rd)%360.0}"
						else
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{de} 1.0 #{(cj+rd)%360.0}"
						end
					else de<dp #円弧が円内
						dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
						if (ms*vc+cc).r<r1 #始点が円内
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{de} 1.0 #{(cj+rd)%360.0}"
						end
					end
				end
			end
		end
	elsif jw.match(/^(c[hvsrptkz2])/) #文字列処理
		#円の内外に関わらず文字列を削除したい場合は
		#次の行の先頭の#を削除してコメントアウトを解除する
		#next
		jch=jw.split(" ")
		vs,ve=jch[1..4].map{|e| e.to_f}.
			each_slice(2).map{|e| Vector.elements(e)}
		vs=vs-v0
		jc0,jc5=jch[0],jch[5][1..-1]
		vb=Matrix[[0,-1],[1,0]]*ve #90°回転
		vh=kouten(vo,vb,vs,vs+ve) #円の中心から線への垂点
		if vh.r<r1
			vp=ve*sqrt(r1**2-(vh.r)**2)*(1.0/ve.r)+vh
			vq=ve*(-1.0)*sqrt(r1**2-(vh.r)**2)*(1.0/ve.r)+vh
			dq,dp,jc5n=0,0,""
			if vs.r<r1 && (ve-vs).r<r1 #始点と終点が円内(q,s,e,p)
				jc5n=jc5
				vsn=vs
			elsif vs.r<r1 #始点が円内(q,s,p,e)
				jc5.each_char{|e|
					if (vp-vs).r>dp
						dp+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
						jc5n+=e
					end}
				vsn=vs
			elsif (ve-vs).r<r1 #終点が円内(s,q,e,p)
				jc5.each_char{|e|
					if (vq-vs).r>dq
						dq+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
					else
						jc5n+=e
					end}
				vsn=vs+ve*dq/ve.r
			elsif ve.dot(vq-vs)>0 && ve.dot(vp-vs)>0 #始点と終点が円を横切る(s,q,p,e)
				jc5.each_char{|e|
					if (vq-vs).r>dq
						dq+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
						dp=dq
					elsif (vp-vs).r>dp
						dp+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
						jc5n+=e
					end}
				vsn=vs+ve*dq/ve.r
			end
			if vsn #円外の文字は書き出さない
				if opt==1
					vsn,ven=vsn+v0,mk*ve
				else
					vsn,ven=mx*vsn,mx*ve
				end
				puts "cn0 #{fcw*n} #{fch*n} #{fcd*n} #{fcc.to_i}" unless n==1.0
				puts %Q|#{jc0} #{vsn[0]} #{vsn[1]} #{ven[0]} #{ven[1]} "#{jc5n}|
			end
		end
	else
		puts jw
	end}
__END__

:END

anonymous No title
Ruby
@REM jww 外部変形
@REM 円外消去.BAT
@REM ruby 1.8.7 に対応
@REM 文字列を処理
@echo off
REM #jww
REM #cd
REM #ht10
REM #ht20
REM #ht40
REM #zz
goto %1
REM #hm【円外消去】 |円外消去|等倍複写|2倍複写|N倍複写|回転複写|
REM #:1
REM #h2
REM #hc  【円外消去】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【円外消去】円を指示
REM #e
REM #:2
REM #h2
REM #hc  【等倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【等倍複写】円を指示
REM #0%d 【等倍複写】複写先指示
REM #e
REM #:3
REM #h2
REM #hc  【2倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【2倍複写】円を指示
REM #0%d 【2倍複写】複写先指示
REM #e
REM #:4
REM #h2
REM #hc  【N倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【N倍複写】円を指示
REM #0%d 【N倍複写】複写先指示
REM #c   【N倍複写】倍率指定(無指定:1) : /_N
REM #e
REM #:5
REM #h2
REM #hc  【回転複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【回転複写】円を指示
REM #0%d 【回転複写】複写先指示
REM #c   【回転複写】倍率指定(無指定:1) : /_N
REM #e

:1
:2
:4
:5
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 %2
GOTO  END
:3
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 N2
GOTO  END

【円外消去】指定した円の外側を消去
【等倍複写】指定した円の外側を消去して複写
【2倍複写】倍率2倍
【N倍複写】倍率N倍
【回転複写】意味はないけどランダムに回転させてみる

#! ruby
# encoding: SJIS

# 座標値を取り込む際に円の中心からの相対座標に直す
# 座標値を出力する際
# 【円外消去】では座標を元に戻す
# 他は行列を使って倍率をかけたり回転させたり

include Math
require 'matrix'

$stdout=open("jwc_temp.txt","w")
$stderr=open("tmp_err.txt","w")

def kouten(a,c,b,d) #外積を使って二線(ab,cd)の交点を求める
	a=Vector.elements(a.to_a)
	b=Vector.elements(b.to_a)
	c=Vector.elements(c.to_a)
	d=Vector.elements(d.to_a)
	#cp1=(d-b).cross(b-a)[2]
	#cp2=(d-b).cross(c-b)[2]
	cp1=(d-b)[0]*(b-a)[1]-(d-b)[1]*(b-a)[0]
	cp2=(d-b)[0]*(c-b)[1]-(d-b)[1]*(c-b)[0]
	k=cp1/(cp1+cp2)
	p=(c-a)*k+a
end

class Vector
	def dot(a)
		self[0]*a[0]+self[1]*a[1]
	end
end

opt=ARGV[0].to_i #1:【円外消去】
jwc=open("jwc_bak.txt").read
n=ARGV.grep(/^N/)[0].to_s.gsub(/^N/,"").to_f
n=1.0 if n==0
mx=Matrix[[n,0],[0,n]]
rd=(opt==5 ? rand(360.0) :0)
mk=Matrix[[cos(rd*PI/180.0),-sin(rd*PI/180.0)],
	[sin(rd*PI/180.0),cos(rd*PI/180.0)]] #回転用行列
mx=mk*mx
vo=Vector[0,0]

cir=jwc.match(/hhp9ci\nci (-?[\d.]+) (-?[\d.]+) (-?[\d.]+)/m).
	to_a.map{|e| e.to_f}[1..3]
v0=Vector.elements(cir[0..1])
r1=cir[2]
hcw,hch,hcd,hcc=[],[],[],[]
fcw,fch,fcd,fcc=0,0,0,0
jwc.split("\n").each{|jw|
	if jw.match(/^hq/)
		puts "hd" if opt==1
	elsif jw.match(/^hc[whdc]/)
		hcw=jw.split(" ").map{|e| e.to_f} if /^hcw/=~jw
		hch=jw.split(" ").map{|e| e.to_f} if /^hch/=~jw
		hcd=jw.split(" ").map{|e| e.to_f} if /^hcd/=~jw
		hcc=jw.split(" ").map{|e| e.to_f} if /^hcc/=~jw
		puts jw
	elsif jw.match(/^cn0 (.*)/)
		fcw,fch,fcd,fcc=$1.split(" ").map{|e| e.to_f}
		puts jw
	elsif jw.match(/^cn([1-9]0?)/)
		cn=$1.to_i
		fcw,fch,fcd,fcc=hcw[cn],hch[cn],hcd[cn],hcc[cn]
		puts jw
	elsif jw.match(/^pt (.*)/) #点の処理
		vp=Vector.elements($1.split(" ").map{|f| f.to_f})
		vp=vp-v0
		if vp.r<r1
			vpn=(opt==1 ? vp+v0 : mx*vp)
			puts "pt "+vpn.to_a.join(" ")
		end
	elsif jw.match(/^( -?[\d.]+){4}/) #線の処理
		vs,ve=$&.split(" ").map{|e| e.to_f}.
			each_slice(2).map{|e| Vector.elements(e)}
		vs,ve=vs-v0,ve-v0
		vs,ve=ve,vs if vs.r>ve.r
		vb=Matrix[[0,-1],[1,0]]*(ve-vs) #90°回転
		vh=kouten(vo,vb,vs,ve) #円の中心から線への垂点
		if vh.r<r1
			vp=(ve-vs)*sqrt(r1**2-(vh.r)**2)*(1.0/(ve-vs).r)+vh
			vq=(vs-ve)*sqrt(r1**2-(vh.r)**2)*(1.0/(ve-vs).r)+vh
			if opt==1
				vsn,ven,vpn,vqn=vs+v0,ve+v0,vp+v0,vq+v0
			else
				vsn,ven,vpn,vqn=mx*vs,mx*ve,mx*vp,mx*vq
			end
			if vs.r<r1 && ve.r<r1 #始点と終点が円内
				puts " "+(vsn.to_a+ven.to_a).join(" ")
			elsif vs.r<r1 #始点が円内
				puts " "+(vsn.to_a+vpn.to_a).join(" ")
			elsif (vq-vs).dot(ve-vs)>0 && (vp-vs).dot(ve-vs)>0 #円を横切る
				puts " "+(vqn.to_a+vpn.to_a).join(" ")
			end
		end
	elsif jw.match(/^ci (.*)/) #円の処理
		ci=$1.split(" ").map{|f| f.to_f}
		cc=Vector.elements(ci[0,2])
		cc=cc-v0								#円弧中心
		r2=ci[2]								#半径
		d=cc.r									#円と円の距離
		ch=(ci[5] ? ci[5] :1.0)	#扁平率
		cj=(ci[6] ? ci[6] :0.0)	#軸角
		ccn=(opt==1 ? cc+v0 : mx*cc)
		if d>r1+r2 #円が離れている場合
			next
		elsif d<r1-r2 or (cc.r==0 && r1==r2)		#円の中に円がある又は円が同一
			if ci[3] #円弧か楕円
				puts "ci "+ccn.to_a.join(" ")+" #{r2*n} "+
					ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
			else
				puts "ci "+ccn.to_a.join(" ")+" #{r2*n}"
			end
		else #交点が存在する場合
			if ch<1.0 #楕円の場合はそのまま出力
				puts "ci "+ccn.to_a.join(" ")+" #{r2*n} "+
					ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
			else
				rad=acos((d**2+r1**2-r2**2)/(2*d*r1)) #余弦定理
				ma=Matrix[[cos(rad),sin(rad)],[-sin(rad),cos(rad)]]
				mb=Matrix[[cos(rad),-sin(rad)],[sin(rad),cos(rad)]]
				vp=ma*cc*(r1/d) #交点1
				vq=mb*cc*(r1/d) #交点2
				vc=Vector[r2,0]
				dp=atan2((vp-cc)[1],(vp-cc)[0])*180/PI
				dq=atan2((vq-cc)[1],(vq-cc)[0])*180/PI
				dp,dq=(dp+360.0)%360.0,(dq+360.0)%360.0
				dp,dq=[dp,dq].sort
				if ci.size==3 #円の場合
					dp,dq=dq,dp if (vc+cc).r<r1 #0°の点が円の外
					puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 #{rd}"
				else #円弧の場合
					ds,de=ci[3]+cj,ci[4]+cj #始角と終角
					de=(de-ds<0 ? de-ds+360.0 : de-ds)
					dp,dq=[dp,dq].map{|e| e-ds<0 ? e-ds+360.0 : e-ds}.sort
					ms=Matrix[[cos(ds*PI/180),-sin(ds*PI/180)],[sin(ds*PI/180),cos(ds*PI/180)]]
					if dq<de #交点が2つ
						if (ms*vc+cc).r<r1 #始点が円内
							dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 #{(cj+rd)%360.0}"
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dq} #{de} 1.0 #{(cj+rd)%360.0}"
						else
							dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 #{(cj+rd)%360.0}"
						end
					elsif dp<de #交点が1つ
						dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
						if (ms*vc+cc).r<r1 #始点が円内
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 #{(cj+rd)%360.0}"
						else
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{dp} #{de} 1.0 #{(cj+rd)%360.0}"
						end
					else de<dp #円弧が円内
						dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
						if (ms*vc+cc).r<r1 #始点が円内
							puts "ci "+ccn.to_a.join(" ")+" #{r2*n} #{ds} #{de} 1.0 #{(cj+rd)%360.0}"
						end
					end
				end
			end
		end
	elsif jw.match(/^(c[hvsrptkz2])/) #文字列処理
		#円の内外に関わらず文字列を削除したい場合は
		#次の行の先頭の#を削除してコメントアウトを解除する
		#next
		jch=jw.split(" ")
		vs,ve=jch[1..4].map{|e| e.to_f}.
			each_slice(2).map{|e| Vector.elements(e)}
		vs=vs-v0
		jc0,jc5=jch[0],jch[5][1..-1]
		vb=Matrix[[0,-1],[1,0]]*ve #90°回転
		vh=kouten(vo,vb,vs,vs+ve) #円の中心から線への垂点
		if vh.r<r1
			vp= ve*sqrt(r1**2-(vh.r)**2)*(1.0/ve.r)+vh
			vq=-ve*sqrt(r1**2-(vh.r)**2)*(1.0/ve.r)+vh
			dq,dp,jc5n=0,0,""
			if vs.r<r1 && (ve-vs).r<r1 #始点と終点が円内(q,s,e,p)
				jc5n=jc5
				vsn=vs
			elsif vs.r<r1 #始点が円内(q,s,p,e)
				jc5.each_char{|e|
					if (vp-vs).r>dp
						dp+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
						jc5n+=e
					end}
				vsn=vs
			elsif (ve-vs).r<r1 #終点が円内(s,q,e,p)
				jc5.each_char{|e|
					if (vq-vs).r>dq
						dq+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
					else
						jc5n+=e
					end}
				vsn=vs+ve*dq/ve.r
			elsif ve.dot(vq-vs)>0 && ve.dot(vp-vs)>0 #始点と終点が円を横切る(s,q,p,e)
				jc5.each_char{|e|
					if (vq-vs).r>dq
						dq+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
						dp=dq
					elsif (vp-vs).r>dp
						dp+=(e.bytesize==1 ? fcw*0.5+fcd*0.5 : fcw+fcd)
						jc5n+=e
					end}
				vsn=vs+ve*dq/ve.r
			end
			if vsn #円外の文字は書き出さない
				if opt==1
					vsn,ven=vsn+v0,mk*ve
				else
					vsn,ven=mx*vsn,mx*ve
				end
				puts "cn0 #{fcw*n} #{fch*n} #{fcd*n} #{fcc.to_i}" unless n==1.0
				puts %Q|#{jc0} #{vsn[0]} #{vsn[1]} #{ven[0]} #{ven[1]} "#{jc5n}|
			end
		end
	else
		puts jw
	end}
__END__

:END
anonymous No title
Ruby
@REM jww 外部変形
@REM 円外消去.BAT
@REM ruby 1.8.7 に対応
@echo off
REM #jww
REM #cd
REM #ht10
REM #ht20
REM #ht40
REM #zz
goto %1
REM #hm【円外消去】 |円外消去|等倍複写|2倍複写|N倍複写|回転複写|
REM #:1
REM #h2
REM #hc  【円外消去】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【円外消去】円を指示
REM #e
REM #:2
REM #h2
REM #hc  【等倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【等倍複写】円を指示
REM #0%d 【等倍複写】複写先指示
REM #e
REM #:3
REM #h2
REM #hc  【2倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【2倍複写】円を指示
REM #0%d 【2倍複写】複写先指示
REM #e
REM #:4
REM #h2
REM #hc  【N倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【N倍複写】円を指示
REM #0%d 【N倍複写】複写先指示
REM #c   【N倍複写】倍率指定(無指定:1) : /_N
REM #e
REM #:5
REM #h2
REM #hc  【回転複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【回転複写】円を指示
REM #0%d 【回転複写】複写先指示
REM #c   【回転複写】倍率指定(無指定:1) : /_N
REM #e

:1
:2
:4
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 %2
GOTO  END
:3
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 N2
GOTO  END
:5
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 -%1 %2
GOTO  END

【円外消去】指定した円の外側を消去
【等倍複写】指定した円の外側を消去して複写
【2倍複写】倍率2倍
【N倍複写】倍率N倍
【回転複写】意味はないけどランダムに回転させてみる

#! ruby
# encoding: SJIS

# 座標値を取り込む際に円の中心からの相対座標に直す
# 座標値を出力する際
# 【円外消去】では座標を元に戻す
# 他は行列を使って倍率をかけたり回転させたり

include Math
require 'matrix'

$stdout=open("jwc_temp.txt","w")
$stderr=open("tmp_err.txt","w")

def kouten(a,c,b,d) #外積を使って二線(ab,cd)の交点を求める
	a=Vector.elements(a.to_a+[0])
	b=Vector.elements(b.to_a+[0])
	c=Vector.elements(c.to_a+[0])
	d=Vector.elements(d.to_a+[0])
	#cp1=(d-b).cross(b-a)[2]
	#cp2=(d-b).cross(c-b)[2]
	cp1=(d-b)[0]*(b-a)[1]-(d-b)[1]*(b-a)[0]
	cp2=(d-b)[0]*(c-b)[1]-(d-b)[1]*(c-b)[0]
	k=cp1/(cp1+cp2)
	p=(c-a)*k+a
	p=Vector.elements(p.to_a[0..1])
end

def dot(a,b)
	a[0]*b[0]+a[1]*b[1]
end

opt=ARGV[0].to_i #1:【円外消去】
jwc=open("jwc_bak.txt").read
n=ARGV.grep(/^N/)[0].to_s.gsub(/^N/,"").to_f
n=1.0 if n==0
mx=Matrix[[n,0],[0,n]]
rd=rand(360.0)
mk=Matrix[[cos(rd*PI/180.0),-sin(rd*PI/180.0)],
	[sin(rd*PI/180.0),cos(rd*PI/180.0)]] #回転用行列
vo=Vector[0,0]

cir=jwc.match(/hhp9ci\nci (-?[\d.]+) (-?[\d.]+) (-?[\d.]+)/m).
	to_a.map{|e| e.to_f}[1..3]
v0=Vector.elements(cir[0..1])
r1=cir[2]

jwc.split("\n").each{|jw|
	if jw.match(/^hq/)
		puts "hd" if opt==1
	elsif jw.match(/^pt (.*)/) #点の処理
		vp=Vector.elements($1.split(" ").map{|f| f.to_f})
		vp=vp-v0
		if vp.r<r1
			puts "pt "+(vp+v0).to_a.join(" ")			if opt==1
			puts "pt "+(mx*vp).to_a.join(" ")			if opt>=2
			puts "pt "+(mk*mx*vp).to_a.join(" ")	if opt==-5
		end
	elsif jw.match(/^( -?[\d.]+){4}/) #線の処理
		vs,ve=$&.split(" ").map{|e| e.to_f}.
			each_slice(2).map{|e| Vector.elements(e)}
		vs,ve=vs-v0,ve-v0
		vs,ve=ve,vs if vs.r>ve.r
		vb=Matrix[[0,-1],[1,0]]*(ve-vs) #90°回転
		vh=kouten(vo,vb,vs,ve) #円の中心から線への垂点
		if vh.r<r1
			vp=(ve-vs)*sqrt(r1**2-(vh.r)**2)*(1.0/(ve-vs).r)+vh
			vq=(vs-ve)*sqrt(r1**2-(vh.r)**2)*(1.0/(ve-vs).r)+vh
			if vs.r<r1 && ve.r<r1
				puts " "+((vs+v0).to_a+(ve+v0).to_a).join(" ")				if opt==1
				puts " "+((mx*vs).to_a+(mx*ve).to_a).join(" ")				if opt>=2
				puts " "+((mk*mx*vs).to_a+(mk*mx*ve).to_a).join(" ")	if opt==-5
			elsif vs.r<r1
				puts " "+((vs+v0).to_a+(vp+v0).to_a).join(" ")				if opt==1
				puts " "+((mx*vs).to_a+(mx*vp).to_a).join(" ")				if opt>=2
				puts " "+((mk*mx*vs).to_a+(mk*mx*vp).to_a).join(" ")	if opt==-5
			elsif dot((vq-vs),(ve-vs))>0 && dot((vp-vs),(ve-vs))>0
				puts " "+((vq+v0).to_a+(vp+v0).to_a).join(" ")				if opt==1
				puts " "+((mx*vq).to_a+(mx*vp).to_a).join(" ")				if opt>=2
				puts " "+((mk*mx*vq).to_a+(mk*mx*vp).to_a).join(" ")	if opt==-5
			end
		end
	elsif jw.match(/^ci (.*)/) #円の処理
		ci=$1.split(" ").map{|f| f.to_f}
		cc=Vector.elements(ci[0,2])
		cc=cc-v0								#円弧中心
		r2=ci[2]								#半径
		d=cc.r									#円と円の距離
		ch=(ci[5] ? ci[5] :1.0)	#扁平率
		cj=(ci[6] ? ci[6] :0.0)	#軸角
		if d>r1+r2 #円が離れている場合
			next
		elsif d<r1-r2 or (cc.r==0 && r1==r2)		#円の中に円がある又は円が同一
			puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} "+ci[3..6].join(" ") if opt==1
			puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} "+ci[3..6].join(" ") if opt>=2
			if opt==-5 && ci[3] #円弧か楕円
				puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} "+
					ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
			elsif opt==-5
				puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n}"
			end
		else #交点が存在する場合
			if ch<1.0 #楕円の場合はそのまま出力
				puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} "+ci[3..6].join(" ") if opt==1
				puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} "+ci[3..6].join(" ") if opt>=2
				puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} "+
					ci[3..5].join(" ")+" #{(cj+rd)%360.0}"	if opt==-5
			else
				rad=acos((d**2+r1**2-r2**2)/(2*d*r1)) #余弦定理
				ma=Matrix[[cos(rad),sin(rad)],[-sin(rad),cos(rad)]]
				mb=Matrix[[cos(rad),-sin(rad)],[sin(rad),cos(rad)]]
				vp=ma*cc*(r1/d) #交点1
				vq=mb*cc*(r1/d) #交点2
				vc=Vector[r2,0]
				dp=atan2((vp-cc)[1],(vp-cc)[0])*180/PI
				dq=atan2((vq-cc)[1],(vq-cc)[0])*180/PI
				dp=dp+360.0 if dp<0
				dq=dq+360.0 if dq<0
				dp,dq=[dp,dq].sort
				if ci.size==3 #円の場合
					dp,dq=dq,dp if (vc+cc).r<r1 #0°の点が円の外
					puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dp} #{dq} 1.0 0" if opt==1
					puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 0" if opt>=2
					puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} "+
						"1.0 #{rd}" if opt==-5
				else #円弧の場合
					ds,de=ci[3]+cj,ci[4]+cj #始角と終角
					de=(de-ds<0 ? de-ds+360.0 : de-ds)
					dp,dq=[dp,dq].map{|e| e-ds<0 ? e-ds+360.0 : e-ds}.sort
					ms=Matrix[[cos(ds*PI/180),-sin(ds*PI/180)],[sin(ds*PI/180),cos(ds*PI/180)]]
					if dq<de #交点が2つ
						if (ms*vc+cc).r<r1 #始点が円内
							dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
							puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{ds} #{dp} 1.0 0" if opt==1
							puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dq} #{de} 1.0 0" if opt==1
							puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 0" if opt>=2
							puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dq} #{de} 1.0 0" if opt>=2
							puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} "+
								"1.0 #{(cj+rd)%360.0}" if opt==-5
							puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dq} #{de} "+
								"1.0 #{(cj+rd)%360.0}" if opt==-5
						else
							dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
							puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dp} #{dq} 1.0 0" if opt==1
							puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 0" if opt>=2
							puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} "+
								"1.0 #{(cj+rd)%360.0}" if opt==-5
						end
					elsif dp<de #交点が1つ
						dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
						if (ms*vc+cc).r<r1 #始点が円内
							puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{ds} #{dp} 1.0 0" if opt==1
							puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 0" if opt>=2
							puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} "+
								"1.0 #{(cj+rd)%360.0}" if opt==-5
						else
							puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dp} #{de} 1.0 0" if opt==1
							puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{de} 1.0 0" if opt>=2
							puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{de} "+
								"1.0 #{(cj+rd)%360.0}" if opt==-5
						end
					else de<dp #円弧が円内
						dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
						if (ms*vc+cc).r<r1 #始点が円内
							puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{ds} #{de} 1.0 0" if opt==1
							puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{de} 1.0 0" if opt>=2
							puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{de} "+
								"1.0 #{(cj+rd)%360.0}" if opt==-5
						end
					end
				end
			end
		end
	else
		puts jw
	end}
__END__

:END

anonymous No title
Ruby
@REM jww 外部変形
@REM 円外消去.BAT
@echo off
REM #jww
REM #cd
REM #ht10
REM #ht20
REM #ht40
REM #zz
goto %1
REM #hm【円外消去】 |円外消去|等倍複写|2倍複写|N倍複写|回転複写|
REM #:1
REM #h2
REM #hc  【円外消去】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【円外消去】円を指示
REM #e
REM #:2
REM #h2
REM #hc  【等倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【等倍複写】円を指示
REM #0%d 【等倍複写】複写先指示
REM #e
REM #:3
REM #h2
REM #hc  【2倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【2倍複写】円を指示
REM #0%d 【2倍複写】複写先指示
REM #e
REM #:4
REM #h2
REM #hc  【N倍複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【N倍複写】円を指示
REM #0%d 【N倍複写】複写先指示
REM #c   【N倍複写】倍率指定(無指定:1) : /_N
REM #e
REM #:5
REM #h2
REM #hc  【回転複写】処理範囲を指定してください
REM #g1
REM #bz
REM #9ci 【回転複写】円を指示
REM #0%d 【回転複写】複写先指示
REM #c   【回転複写】倍率指定(無指定:1) : /_N
REM #e

:1
:2
:4
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 %2
GOTO  END
:3
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 %1 N2
GOTO  END
:5
copy jwc_temp.txt jwc_bak.txt
rubyw -x %~f0 -%1 %2
GOTO  END

【円外消去】指定した円の外側を消去
【等倍複写】指定した円の外側を消去して複写
【2倍複写】倍率2倍
【N倍複写】倍率N倍
【回転複写】意味はないけどランダムに回転させてみる

#! ruby
# encoding: SJIS

# 座標値を取り込む際に円の中心からの相対座標に直す
# 座標値を出力する際
# 【円外消去】では座標を元に戻す
# 他は行列を使って倍率をかけたり回転させたり

include Math
require 'matrix'

$stdout=open("jwc_temp.txt","w")
$stderr=open("tmp_err.txt","w")

def kouten(a,c,b,d) #外積を使って二線(ab,cd)の交点を求める
  a=Vector.elements(a.to_a+[0])
  b=Vector.elements(b.to_a+[0])
  c=Vector.elements(c.to_a+[0])
  d=Vector.elements(d.to_a+[0])
  cp1=(d-b).cross(b-a)[2]
  cp2=(d-b).cross(c-b)[2]
  k=cp1/(cp1+cp2)
  p=k*(c-a)+a
  p=Vector.elements(p.to_a[0..1])
end

opt=ARGV[0].to_i #1:【円外消去】
jwc=open("jwc_bak.txt").read
n=ARGV.grep(/^N/)[0].to_s.gsub(/^N/,"").to_f
n=1.0 if n==0
mx=Matrix[[n,0],[0,n]]
rd=rand(0.0..360.0)
mk=Matrix[[cos(rd*PI/180.0),-sin(rd*PI/180.0)],
  [sin(rd*PI/180.0),cos(rd*PI/180.0)]] #回転用行列
vo=Vector[0,0]

cir=jwc.match(/hhp9ci\nci (-?[\d.]+) (-?[\d.]+) (-?[\d.]+)/m).
  to_a.map{|e| e.to_f}[1..3]
v0=Vector.elements(cir[0..1])
r1=cir[2]

jwc.split("\n").each{|jw|
  if jw.match(/^hq/)
    puts "hd" if opt==1
  elsif jw.match(/^pt (.*)/) #点の処理
    vp=Vector.elements($1.split(" ").map{|f| f.to_f})
    vp=vp-v0
    if vp.r<r1
      puts "pt "+(vp+v0).to_a.join(" ")      if opt==1
      puts "pt "+(mx*vp).to_a.join(" ")      if opt>=2
      puts "pt "+(mk*mx*vp).to_a.join(" ")  if opt==-5
    end
  elsif jw.match(/^( -?[\d.]+){4}/) #線の処理
    vs,ve=$&.split(" ").map{|e| e.to_f}.
      each_slice(2).map{|e| Vector.elements(e)}
    vs,ve=vs-v0,ve-v0
    vs,ve=ve,vs if vs.r>ve.r
    vb=Matrix[[0,-1],[1,0]]*(ve-vs) #90°回転
    vh=kouten(vo,vb,vs,ve) #円の中心から線への垂点
    if vh.r<r1
      vp=(ve-vs)*sqrt(r1**2-(vh.r)**2)/(ve-vs).r+vh
      vq=(vs-ve)*sqrt(r1**2-(vh.r)**2)/(ve-vs).r+vh
      if vs.r<r1 && ve.r<r1
        puts " "+((vs+v0).to_a+(ve+v0).to_a).join(" ")        if opt==1
        puts " "+((mx*vs).to_a+(mx*ve).to_a).join(" ")        if opt>=2
        puts " "+((mk*mx*vs).to_a+(mk*mx*ve).to_a).join(" ")  if opt==-5
      elsif vs.r<r1
        puts " "+((vs+v0).to_a+(vp+v0).to_a).join(" ")        if opt==1
        puts " "+((mx*vs).to_a+(mx*vp).to_a).join(" ")        if opt>=2
        puts " "+((mk*mx*vs).to_a+(mk*mx*vp).to_a).join(" ")  if opt==-5
      elsif (ve-vs).dot(vq-vs)>0 && (ve-vs).dot(vp-vs)>0
        puts " "+((vq+v0).to_a+(vp+v0).to_a).join(" ")        if opt==1
        puts " "+((mx*vq).to_a+(mx*vp).to_a).join(" ")        if opt>=2
        puts " "+((mk*mx*vq).to_a+(mk*mx*vp).to_a).join(" ")  if opt==-5
      end
    end
  elsif jw.match(/^ci (.*)/) #円の処理
    ci=$1.split(" ").map{|f| f.to_f}
    cc=Vector.elements(ci[0,2])
    cc=cc-v0                #円弧中心
    r2=ci[2]                #半径
    d=cc.r                  #円と円の距離
    ch=(ci[5] ? ci[5] :1.0)  #扁平率
    cj=(ci[6] ? ci[6] :0.0)  #軸角
    if d>r1+r2 #円が離れている場合
      next
    elsif d<r1-r2 or (cc.r==0 && r1==r2)    #円の中に円がある又は円が同一
      puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} "+ci[3..6].join(" ") if opt==1
      puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} "+ci[3..6].join(" ") if opt>=2
      if opt==-5 && ci[3] #円弧か楕円
        puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} "+
          ci[3..5].join(" ")+" #{(cj+rd)%360.0}"
      elsif opt==-5
        puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n}"
      end
    else #交点が存在する場合
      if ch<1.0 #楕円の場合はそのまま出力
        puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} "+ci[3..6].join(" ") if opt==1
        puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} "+ci[3..6].join(" ") if opt>=2
        puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} "+
          ci[3..5].join(" ")+" #{(cj+rd)%360.0}"  if opt==-5
      else
        rad=acos((d**2+r1**2-r2**2)/(2*d*r1)) #余弦定理
        ma=Matrix[[cos(rad),sin(rad)],[-sin(rad),cos(rad)]]
        mb=Matrix[[cos(rad),-sin(rad)],[sin(rad),cos(rad)]]
        vp=ma*cc*(r1/d) #交点1
        vq=mb*cc*(r1/d) #交点2
        vc=Vector[r2,0]
        dp=atan2((vp-cc)[1],(vp-cc)[0])*180/PI
        dq=atan2((vq-cc)[1],(vq-cc)[0])*180/PI
        dp=dp+360.0 if dp<0
        dq=dq+360.0 if dq<0
        dp,dq=[dp,dq].sort
        if ci.size==3 #円の場合
          dp,dq=dq,dp if (vc+cc).r<r1 #0°の点が円の外
          puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dp} #{dq} 1.0 0" if opt==1
          puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 0" if opt>=2
          puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} "+
            "1.0 #{rd}" if opt==-5
        else #円弧の場合
          ds,de=ci[3]+cj,ci[4]+cj #始角と終角
          de=(de-ds<0 ? de-ds+360.0 : de-ds)
          dp,dq=[dp,dq].map{|e| e-ds<0 ? e-ds+360.0 : e-ds}.sort
          ms=Matrix[[cos(ds*PI/180),-sin(ds*PI/180)],[sin(ds*PI/180),cos(ds*PI/180)]]
          if dq<de #交点が2つ
            if (ms*vc+cc).r<r1 #始点が円内
              dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
              puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{ds} #{dp} 1.0 0" if opt==1
              puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dq} #{de} 1.0 0" if opt==1
              puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 0" if opt>=2
              puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dq} #{de} 1.0 0" if opt>=2
              puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} "+
                "1.0 #{(cj+rd)%360.0}" if opt==-5
              puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dq} #{de} "+
                "1.0 #{(cj+rd)%360.0}" if opt==-5
            else
              dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
              puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dp} #{dq} 1.0 0" if opt==1
              puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} 1.0 0" if opt>=2
              puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{dq} "+
                "1.0 #{(cj+rd)%360.0}" if opt==-5
            end
          elsif dp<de #交点が1つ
            dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
            if (ms*vc+cc).r<r1 #始点が円内
              puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{ds} #{dp} 1.0 0" if opt==1
              puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} 1.0 0" if opt>=2
              puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{dp} "+
                "1.0 #{(cj+rd)%360.0}" if opt==-5
            else
              puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{dp} #{de} 1.0 0" if opt==1
              puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{de} 1.0 0" if opt>=2
              puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{dp} #{de} "+
                "1.0 #{(cj+rd)%360.0}" if opt==-5
            end
          else de<dp #円弧が円内
            dp,dq,de=[dp,dq,de].map{|e| (e+ds)%360}
            if (ms*vc+cc).r<r1 #始点が円内
              puts "ci "+(cc+v0).to_a.join(" ")+" #{r2} #{ds} #{de} 1.0 0" if opt==1
              puts "ci "+(mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{de} 1.0 0" if opt>=2
              puts "ci "+(mk*mx*cc).to_a.join(" ")+" #{r2*n} #{ds} #{de} "+
                "1.0 #{(cj+rd)%360.0}" if opt==-5
            end
          end
        end
      end
    end
  else
    puts jw
  end}
__END__

:END

Don't you submit code?
Submit
12
年末年始は機械学習・深層学習を勉強しませんか?
広告
未経験から最短でエンジニアへの転職を目指すなら