├── procs ├── detection │ ├── notes.html │ └── code │ │ └── image │ │ ├── im1.jpg │ │ ├── im2.jpg │ │ ├── coins.jpg │ │ ├── greekmask.odg │ │ ├── greekmask.png │ │ └── greekstat.jpg ├── theme │ ├── tex │ │ ├── d1point.pdf │ │ ├── d2point.pdf │ │ ├── mksvg.sh │ │ ├── d1point.tex │ │ └── d2point.tex │ ├── image │ │ ├── processing │ │ │ ├── bear.jpg │ │ │ ├── prewitt1.jpg │ │ │ └── sinewave.svg │ │ ├── projects │ │ │ └── testimg.png │ │ └── math │ │ │ ├── d1point.svg │ │ │ ├── seqRel.svg │ │ │ ├── d2point.svg │ │ │ ├── phong.svg │ │ │ ├── sequence.svg │ │ │ ├── polarPoint.svg │ │ │ ├── trig.svg │ │ │ ├── derivSecant.svg │ │ │ ├── triangleRelations.svg │ │ │ ├── xyzPoint.svg │ │ │ └── pisagor2d.svg │ └── css │ │ └── prism.css ├── processing │ └── code │ │ └── image │ │ ├── im1.jpg │ │ ├── im2.jpg │ │ └── greekstat.jpg ├── solutions │ ├── formation │ │ └── scattering.html │ └── math │ │ ├── trigonometry.html │ │ ├── transformation.html │ │ ├── calculus.html │ │ └── primitives.html ├── index.html ├── projects │ └── notes.html └── formation │ └── notes.html ├── README.md └── .gitignore /procs/detection/notes.html: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /procs/theme/tex/d1point.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/theme/tex/d1point.pdf -------------------------------------------------------------------------------- /procs/theme/tex/d2point.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/theme/tex/d2point.pdf -------------------------------------------------------------------------------- /procs/detection/code/image/im1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/detection/code/image/im1.jpg -------------------------------------------------------------------------------- /procs/detection/code/image/im2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/detection/code/image/im2.jpg -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # image-procs 2 | Implementation of Image processing Algorithms Explained 3 | 4 | See [index](procs/index.html) 5 | -------------------------------------------------------------------------------- /procs/detection/code/image/coins.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/detection/code/image/coins.jpg -------------------------------------------------------------------------------- /procs/processing/code/image/im1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/processing/code/image/im1.jpg -------------------------------------------------------------------------------- /procs/processing/code/image/im2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/processing/code/image/im2.jpg -------------------------------------------------------------------------------- /procs/theme/image/processing/bear.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/theme/image/processing/bear.jpg -------------------------------------------------------------------------------- /procs/theme/image/projects/testimg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/theme/image/projects/testimg.png -------------------------------------------------------------------------------- /procs/detection/code/image/greekmask.odg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/detection/code/image/greekmask.odg -------------------------------------------------------------------------------- /procs/detection/code/image/greekmask.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/detection/code/image/greekmask.png -------------------------------------------------------------------------------- /procs/detection/code/image/greekstat.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/detection/code/image/greekstat.jpg -------------------------------------------------------------------------------- /procs/processing/code/image/greekstat.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/processing/code/image/greekstat.jpg -------------------------------------------------------------------------------- /procs/theme/image/processing/prewitt1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/D-K-E/image-procs/master/procs/theme/image/processing/prewitt1.jpg -------------------------------------------------------------------------------- /procs/theme/tex/mksvg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | read -p "Enter tex filename [Ex. myfile] no extension: " texfile 4 | latex "${texfile}.tex" 5 | dvisvgm -e --no-merge "${texfile}.dvi" 6 | mv "${texfile}.svg" ../image/ 7 | 8 | -------------------------------------------------------------------------------- /procs/theme/tex/d1point.tex: -------------------------------------------------------------------------------- 1 | \documentclass[dvisvgm]{minimal} 2 | \usepackage{tikz} 3 | \thispagestyle{empty} 4 | \begin{document} 5 | \begin{tikzpicture} 6 | \draw[<->] (-5, 0) -- (5,0); 7 | \draw[fill] (-2, 0) circle (0.2em) node[above] {x}; 8 | \draw[fill] (2, 0) circle (0.2em) node[above] {xi}; 9 | \draw[red, dashed] (-1.9, -0.3) -- (1.9, -0.3); 10 | \draw (0, -0.4) node[below,color=red] {\(\Delta\) x}; 11 | \end{tikzpicture} 12 | 13 | \end{document} 14 | -------------------------------------------------------------------------------- /procs/solutions/formation/scattering.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Image Formation Solutions 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /procs/theme/tex/d2point.tex: -------------------------------------------------------------------------------- 1 | \documentclass[dvisvgm]{minimal} 2 | \usepackage{tikz} 3 | \thispagestyle{empty} 4 | \begin{document} 5 | \begin{tikzpicture} 6 | \draw (-2, 0) -- (2, 0) node[above] {x}; 7 | \draw (0, -2) -- (0, 2) node[above] {y}; 8 | \draw[fill] (0, 0) circle (0.3 em); 9 | \node[left] at (-0.3, -0.5) {O}; 10 | \draw[fill] (1, 1.5) circle (0.2 em) node[right] {P}; 11 | \draw[dashed, orange] (1,0) -- (1, 1.5); 12 | \node[below] at (1,0) {a}; 13 | \draw[dashed, blue] (0, 1.5) -- (1, 1.5); 14 | \node[left] at (-0.3, 1.5) {p(a)}; 15 | \end{tikzpicture} 16 | 17 | \end{document} 18 | -------------------------------------------------------------------------------- /procs/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 |

Parts

13 |
14 | 36 |
37 |
38 |
39 |

Chapitres

40 |
41 | 53 |
54 |
55 | 56 | 57 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /procs/theme/image/math/d1point.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | x 45 | 46 | 47 | 48 | 49 | 50 | x 51 | i 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | ∆ 66 | x 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /procs/theme/image/math/seqRel.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | 21 | 43 | 45 | 46 | 48 | image/svg+xml 49 | 51 | 52 | 53 | 54 | 55 | 60 | 67 | 75 | 82 | Bounded 93 | Monotonic 104 | Convergent 115 | Infinite Sequence Relations 127 | 128 | 129 | -------------------------------------------------------------------------------- /procs/solutions/math/trigonometry.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Elements of Trigonometry Solutions 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 |
18 |
    19 |
  1. 20 |
    21 |

    22 | c,ρ,h,m: write a program to compute the perimeter of the triangle 23 |

    24 |
      25 |
    1. 26 | \(c^2 = h^2 + k^2\) 27 |
      2. 28 |
    2. 29 | \(c^2 - h^2 = k^2\) 30 |
      3. 31 |
    3. 32 | \(a = \sqrt{k^2} + m\) 33 |
      4. 34 |
    4. 35 | \(\cos(\beta) = k / c \) 36 |
      5. 37 |
    5. 38 | \(b^2 = a^2 + c^2 - 2ac \cos(\beta)\) 39 |
      6. 40 |
    6. 41 | \(perimeter = a + c + \sqrt{b^2}\) 42 |
      7. 43 |
    44 |
    45 |
    2. 46 |
  2. 47 |
    48 |

    49 | θ,β,b: write a program to compute the perimeter of the triangle 50 |

    51 |
      52 |
    1. 53 | \(m =\cos(\theta) * b\) 54 |
      2. 55 |
    2. 56 | \(h = \sin(\theta) * b\) 57 |
      3. 58 |
    3. 59 | \(c = h / \sin(\beta) \) 60 |
      4. 61 |
    4. 62 | \(k = \cos(\beta) * c \) 63 |
      5. 64 |
    5. \(b^2 - h^2 = m^2 \)
      6. 65 |
    6. 66 | \( perimeter = c + b + \sqrt{m^2} + k \) 67 |
      7. 68 |
    69 |
    70 |
    3. 71 |
  3. 72 |
    73 |

    74 | k, h, m: write a program to compute the perimeter of the triangle 75 |

    76 |
      77 |
    1. 78 | \(c = \sqrt{k^2 + h^2} \) 79 |
      2. 80 |
    2. 81 | \( \cos(\beta) = k / c \) 82 |
      3. 83 |
    3. 84 | \(a = k + m\) 85 |
      4. 86 |
    4. 87 | \( b^2 = c^2 + a^2 - 2ac \cos(\beta) \) 88 |
      5. 89 |
    5. 90 | \(perimeter = a + c + \sqrt{b^2} \) 91 |
      6. 92 |
    93 |
    94 |
    4. 95 |
  4. 96 |
    97 |

    98 | β, θ, c: write a program to compute the perimeter of the triangle 99 |

    100 |
      101 |
    1. 102 | \( c \sin(\beta) / \sin(\theta) = b \) 103 |
      2. 104 |
    2. 105 | \( \alpha = \rho + \epsilon = 180 - (\beta + \theta) \) 106 |
      3. 107 |
    3. 108 | \(a^2 = c^2 + b^2 - 2bc \cos(\alpha) \) 109 |
      4. 110 |
    4. 111 | \( perimeter = c + b + \sqrt{a^2} \) 112 |
      5. 113 |
    114 |
    115 |
    5. 116 |
  5. 117 |
    118 |

    119 | h, θ, ρ: write a program to compute the perimeter of the triangle 120 |

    121 |
      122 |
    1. 123 | \( \beta = 90 - \rho \) 124 |
      2. 125 |
    2. 126 | \(c = h / \sin(\beta) \) 127 |
      3. 128 |
    3. 129 | \( c \sin(\beta) / \sin(\theta) = b \) 130 |
      4. 131 |
    4. 132 | \( m^2 = b^2 - h^2 \) 133 |
      5. 134 |
    5. 135 | \( k^2 = c^2 - h^2 \) 136 |
      6. 137 |
    6. 138 | \( perimeter = c + b + \sqrt{m^2} + \sqrt{k^2} \) 139 |
      7. 140 |
    141 |
    142 |
    6. 143 |
144 | 145 | 147 | 148 | 149 | 151 | 152 | 153 | 154 | 155 | 156 | -------------------------------------------------------------------------------- /procs/theme/image/math/d2point.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 21 | 22 | 23 | 24 | 25 | 26 | x 27 | 28 | 29 | 30 | 31 | 32 | y 33 | 34 | 35 | 36 | 37 | 38 | O 39 | 40 | 41 | 42 | 43 | 44 | P 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | a 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | p 65 | ( 66 | a 67 | ) 68 | 69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | 34 | # cmake gitignore 35 | CMakeLists.txt.user 36 | CMakeCache.txt 37 | CMakeFiles 38 | CMakeScripts 39 | Testing 40 | Makefile 41 | cmake_install.cmake 42 | install_manifest.txt 43 | compile_commands.json 44 | CTestTestfile.cmake 45 | _deps 46 | 47 | # Haskell gitignore 48 | 49 | dist 50 | dist-* 51 | cabal-dev 52 | *.o 53 | *.hi 54 | *.hie 55 | *.chi 56 | *.chs.h 57 | *.dyn_o 58 | *.dyn_hi 59 | .hpc 60 | .hsenv 61 | .cabal-sandbox/ 62 | cabal.sandbox.config 63 | *.prof 64 | *.aux 65 | *.hp 66 | *.eventlog 67 | .stack-work/ 68 | cabal.project.local 69 | cabal.project.local~ 70 | .HTF/ 71 | .ghc.environment.* 72 | 73 | # nim gitignore 74 | nimcache/ 75 | nimblecache/ 76 | htmldocs/ 77 | 78 | # python gitignore 79 | 80 | # Byte-compiled / optimized / DLL files 81 | __pycache__/ 82 | *.py[cod] 83 | *$py.class 84 | 85 | # C extensions 86 | *.so 87 | 88 | # Distribution / packaging 89 | .Python 90 | build/ 91 | develop-eggs/ 92 | dist/ 93 | downloads/ 94 | eggs/ 95 | .eggs/ 96 | lib/ 97 | lib64/ 98 | parts/ 99 | sdist/ 100 | var/ 101 | wheels/ 102 | pip-wheel-metadata/ 103 | share/python-wheels/ 104 | *.egg-info/ 105 | .installed.cfg 106 | *.egg 107 | MANIFEST 108 | 109 | # PyInstaller 110 | # Usually these files are written by a python script from a template 111 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 112 | *.manifest 113 | *.spec 114 | 115 | # Installer logs 116 | pip-log.txt 117 | pip-delete-this-directory.txt 118 | 119 | # Unit test / coverage reports 120 | htmlcov/ 121 | .tox/ 122 | .nox/ 123 | .coverage 124 | .coverage.* 125 | .cache 126 | nosetests.xml 127 | coverage.xml 128 | *.cover 129 | *.py,cover 130 | .hypothesis/ 131 | .pytest_cache/ 132 | 133 | # Translations 134 | *.mo 135 | *.pot 136 | 137 | # Django stuff: 138 | *.log 139 | local_settings.py 140 | db.sqlite3 141 | db.sqlite3-journal 142 | 143 | # Flask stuff: 144 | instance/ 145 | .webassets-cache 146 | 147 | # Scrapy stuff: 148 | .scrapy 149 | 150 | # Sphinx documentation 151 | docs/_build/ 152 | 153 | # PyBuilder 154 | target/ 155 | 156 | # Jupyter Notebook 157 | .ipynb_checkpoints 158 | 159 | # IPython 160 | profile_default/ 161 | ipython_config.py 162 | 163 | # pyenv 164 | .python-version 165 | 166 | # pipenv 167 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 168 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 169 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 170 | # install all needed dependencies. 171 | #Pipfile.lock 172 | 173 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 174 | __pypackages__/ 175 | 176 | # Celery stuff 177 | celerybeat-schedule 178 | celerybeat.pid 179 | 180 | # SageMath parsed files 181 | *.sage.py 182 | 183 | # Environments 184 | .env 185 | .venv 186 | env/ 187 | venv/ 188 | ENV/ 189 | env.bak/ 190 | venv.bak/ 191 | 192 | # Spyder project settings 193 | .spyderproject 194 | .spyproject 195 | 196 | # Rope project settings 197 | .ropeproject 198 | 199 | # mkdocs documentation 200 | /site 201 | 202 | # mypy 203 | .mypy_cache/ 204 | .dmypy.json 205 | dmypy.json 206 | 207 | # Pyre type checker 208 | .pyre/ 209 | 210 | # latex ignore 211 | ## Core latex/pdflatex auxiliary files: 212 | *.aux 213 | *.lof 214 | *.log 215 | *.lot 216 | *.fls 217 | *.out 218 | *.toc 219 | *.fmt 220 | *.fot 221 | *.cb 222 | *.cb2 223 | .*.lb 224 | 225 | ## Intermediate documents: 226 | *.dvi 227 | *.xdv 228 | *-converted-to.* 229 | # these rules might exclude image files for figures etc. 230 | # *.ps 231 | # *.eps 232 | # *.pdf 233 | 234 | ## Generated if empty string is given at "Please type another file name for output:" 235 | .pdf 236 | 237 | ## Bibliography auxiliary files (bibtex/biblatex/biber): 238 | *.bbl 239 | *.bcf 240 | *.blg 241 | *-blx.aux 242 | *-blx.bib 243 | *.run.xml 244 | 245 | ## Build tool auxiliary files: 246 | *.fdb_latexmk 247 | *.synctex 248 | *.synctex(busy) 249 | *.synctex.gz 250 | *.synctex.gz(busy) 251 | *.pdfsync 252 | 253 | ## Build tool directories for auxiliary files 254 | # latexrun 255 | latex.out/ 256 | 257 | ## Auxiliary and intermediate files from other packages: 258 | # algorithms 259 | *.alg 260 | *.loa 261 | 262 | # achemso 263 | acs-*.bib 264 | 265 | # amsthm 266 | *.thm 267 | 268 | # beamer 269 | *.nav 270 | *.pre 271 | *.snm 272 | *.vrb 273 | 274 | # changes 275 | *.soc 276 | 277 | # comment 278 | *.cut 279 | 280 | # cprotect 281 | *.cpt 282 | 283 | # elsarticle (documentclass of Elsevier journals) 284 | *.spl 285 | 286 | # endnotes 287 | *.ent 288 | 289 | # fixme 290 | *.lox 291 | 292 | # feynmf/feynmp 293 | *.mf 294 | *.mp 295 | *.t[1-9] 296 | *.t[1-9][0-9] 297 | *.tfm 298 | 299 | #(r)(e)ledmac/(r)(e)ledpar 300 | *.end 301 | *.?end 302 | *.[1-9] 303 | *.[1-9][0-9] 304 | *.[1-9][0-9][0-9] 305 | *.[1-9]R 306 | *.[1-9][0-9]R 307 | *.[1-9][0-9][0-9]R 308 | *.eledsec[1-9] 309 | *.eledsec[1-9]R 310 | *.eledsec[1-9][0-9] 311 | *.eledsec[1-9][0-9]R 312 | *.eledsec[1-9][0-9][0-9] 313 | *.eledsec[1-9][0-9][0-9]R 314 | 315 | # glossaries 316 | *.acn 317 | *.acr 318 | *.glg 319 | *.glo 320 | *.gls 321 | *.glsdefs 322 | *.lzo 323 | *.lzs 324 | 325 | # uncomment this for glossaries-extra (will ignore makeindex's style files!) 326 | # *.ist 327 | 328 | # gnuplottex 329 | *-gnuplottex-* 330 | 331 | # gregoriotex 332 | *.gaux 333 | *.gtex 334 | 335 | # htlatex 336 | *.4ct 337 | *.4tc 338 | *.idv 339 | *.lg 340 | *.trc 341 | *.xref 342 | 343 | # hyperref 344 | *.brf 345 | 346 | # knitr 347 | *-concordance.tex 348 | # TODO Comment the next line if you want to keep your tikz graphics files 349 | *.tikz 350 | *-tikzDictionary 351 | 352 | # listings 353 | *.lol 354 | 355 | # luatexja-ruby 356 | *.ltjruby 357 | 358 | # makeidx 359 | *.idx 360 | *.ilg 361 | *.ind 362 | 363 | # minitoc 364 | *.maf 365 | *.mlf 366 | *.mlt 367 | *.mtc[0-9]* 368 | *.slf[0-9]* 369 | *.slt[0-9]* 370 | *.stc[0-9]* 371 | 372 | # minted 373 | _minted* 374 | *.pyg 375 | 376 | # morewrites 377 | *.mw 378 | 379 | # nomencl 380 | *.nlg 381 | *.nlo 382 | *.nls 383 | 384 | # pax 385 | *.pax 386 | 387 | # pdfpcnotes 388 | *.pdfpc 389 | 390 | # sagetex 391 | *.sagetex.sage 392 | *.sagetex.py 393 | *.sagetex.scmd 394 | 395 | # scrwfile 396 | *.wrt 397 | 398 | # sympy 399 | *.sout 400 | *.sympy 401 | sympy-plots-for-*.tex/ 402 | 403 | # pdfcomment 404 | *.upa 405 | *.upb 406 | 407 | # pythontex 408 | *.pytxcode 409 | pythontex-files-*/ 410 | 411 | # tcolorbox 412 | *.listing 413 | 414 | # thmtools 415 | *.loe 416 | 417 | # TikZ & PGF 418 | *.dpth 419 | *.md5 420 | *.auxlock 421 | 422 | # todonotes 423 | *.tdo 424 | 425 | # vhistory 426 | *.hst 427 | *.ver 428 | 429 | # easy-todo 430 | *.lod 431 | 432 | # xcolor 433 | *.xcp 434 | 435 | # xmpincl 436 | *.xmpi 437 | 438 | # xindy 439 | *.xdy 440 | 441 | # xypic precompiled matrices and outlines 442 | *.xyc 443 | *.xyd 444 | 445 | # endfloat 446 | *.ttt 447 | *.fff 448 | 449 | # Latexian 450 | TSWLatexianTemp* 451 | 452 | ## Editors: 453 | # WinEdt 454 | *.bak 455 | *.sav 456 | 457 | # Texpad 458 | .texpadtmp 459 | 460 | # LyX 461 | *.lyx~ 462 | 463 | # Kile 464 | *.backup 465 | 466 | # gummi 467 | .*.swp 468 | 469 | # KBibTeX 470 | *~[0-9]* 471 | 472 | # TeXnicCenter 473 | *.tps 474 | 475 | # auto folder when using emacs and auctex 476 | ./auto/* 477 | *.el 478 | 479 | # expex forward references with \gathertags 480 | *-tags.tex 481 | 482 | # standalone packages 483 | *.sta 484 | 485 | # Makeindex log files 486 | *.lpz 487 | -------------------------------------------------------------------------------- /procs/theme/image/math/phong.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | 21 | 29 | 34 | 35 | 43 | 48 | 49 | 57 | 62 | 63 | 64 | 87 | 92 | 93 | 95 | 96 | 98 | image/svg+xml 99 | 101 | 102 | 103 | 104 | 105 | 110 | 116 | 121 | 126 | N 137 | L 148 | R 159 | 164 | V 175 | surface 187 | 188 | 189 | -------------------------------------------------------------------------------- /procs/theme/image/math/sequence.svg: -------------------------------------------------------------------------------- 1 |
1
1
1/2
1/2
1/3
1/3
1/4
1/4
1/5
1/5
1/6
1/6
...
... 2 | -------------------------------------------------------------------------------- /procs/solutions/math/transformation.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Image Formation Solutions 8 | 9 | 10 | 11 | 12 | 13 |
14 | 31 |
32 |
33 | 
 34 | 
 35 | 
 36 | import Data.Matrix
 37 | 
 38 | -- rectCenter takes topleft coordinate, width, height
 39 | rectCenter :: (Float, Float, Float) -> Float -> Float -> (Float,
 40 | Float, Float)
 41 | rectCenter (x, y, z) width, height =
 42 |     (x+width/2, y+height/2, z)
 43 | 
 44 | normVec :: (Float, Float, Float) -> (Float, Float, Float)
 45 | normVec (x, y, z) = let n = sqrt (x*x + y*y + z*z)
 46 |                     in (x/n, y/n, z/n)
 47 | 
 48 | -- Answer 1
 49 | -- cameraDir takes position and target as arguments
 50 | cameraDir :: (Float, Float, Float) -> (Float, Float, Float) -> (Float,
 51 | Float, Float)
 52 | 
 53 | cameraDir (xp, yp, zp) (xt, yt, zt) = 
 54 |     normVec (xt-xp, yt-yp, zt - zp)
 55 | 
 56 | -- Answer 2
 57 | -- cameraSpaceXAxis takes camera direction as argument
 58 | cameraSpaceXAxis :: (Float, Float, Float) -> (Float, Float, Float)
 59 | cameraSpaceXAxis cameraDir =
 60 |     cross (0, 1, 0) cameraDir
 61 | -- for implementation of cross see math notes
 62 | 
 63 | cameraSpaceYAxis :: (Float, Float, Float) -> (Float, Float, Float) ->
 64 | (Float, Float, Float)
 65 | 
 66 | cameraSpaceYAxis cameraDir xaxis = 
 67 |     cross cameraDir xaxis
 68 | 
 69 | -- computeViewSpace takes xaxis, yaxis, zaxis and a position as arguments
 70 | computeViewSpace :: (Float, Float, Float) -> (Float, Float, Float) ->
 71 | (Float, Float, Float) -> (Float, Float, Float) -> (Float, Float,
 72 | Float)
 73 | 
 74 | computeViewSpace (xx, yx, zx) (xy, yy, zy) (xz, yz, zz) (px, py, pz) =
 75 |     multStd (fromList [[xx, yx, zx, 0], 
 76 |               [xy, yy, zy, 0],
 77 |               [xz, yz, zz, 0],
 78 |               [0, 0, 0, 1]]) (
 79 |                 fromList [
 80 |                     [1, 0, 0, -px],
 81 |                     [0, 1, 0, -py], 
 82 |                     [0, 0, 1, -pz], 
 83 |                     [0, 0, 0, 1]
 84 |                     ]
 85 |                 )
 86 | 
 87 | 
 88 | -- Answer 3
 89 | 
 90 | 
 91 |
92 |
93 |
94 | 
 95 | 
 96 | import math
 97 | 
 98 | def rectCenter(topleft: (float, float, float), width: float, height: float):
 99 |     return (topleft[0]+width/2, topleft[1]+height/2, topleft[2]) 
100 | 
101 | def normVec(x,y,z):
102 |     norm = math.sqrt(x*x + y*y + z*z)
103 |     return (x/norm, y/norm, z/norm)
104 | 
105 | def cameraDir(pos, target):
106 |     return normVec(*(target[0] - pos[0],
107 |                     target[1] - pos[1],
108 |                     target[2] - pos[2]))
109 | 
110 | def cameraSpaceXAxis(dir):
111 |     return cross((0,1,0), dir)
112 | 
113 | def cameraSpaceYAxis(cameraDir, xaxis):
114 |     return cross(cameraDir, xaxis)
115 | 
116 | def computeViewSpace(xaxis, yaxis, zaxis, pos):
117 |     mat1 = [[*xaxis, 0], [*yaxis, 0], [*zaxis, 0]]
118 |     mat2 = [[1, 0, 0, -pos[0]], 
119 |             [0, 1, 0, -pos[1]],
120 |             [0, 0, 1, -pos[2]],
121 |             [0, 0, 0, 1]]
122 |     return matmul(mat1, mat2)
123 | 
124 | # answer 3
125 | 
126 | def move(pos, dir, unit):
127 |     #
128 |     dir = [dir[0]*unit, dir[1] * unit, dir[2] * unit]
129 |     mat = [[1, 0, 0, dir[0]], 
130 |            [0, 1, 0, dir[1]],
131 |            [0, 0, 1, dir[2]],
132 |            [0, 0, 0, 1]]
133 |     pos = [pos[0], pos[1], pos[2], 1]
134 |     return mat2vec(mat, pos)
135 | # for mat2vec implementation see solution of
136 | # primitives
137 |             
138 | 
139 |
140 |
141 |
142 | 
143 | 
144 | 
145 | 
146 |
147 |
148 |
149 | 
150 | 
151 | 
152 | 
153 |
154 |
155 |
156 |
    157 |
  1. Compute the direction vector of the camera pointing to 158 | the center of the rectangle 159 |
    2. 160 |
  2. 161 | Compute the view space coordinates of the rectangle 162 |
    3. 163 |
  3. 164 | Move rectangle 5 units in the direction 165 | {"x": 0.55, "y": 0.37, "z": 0.74} 166 | and draw it using perspective projection 167 |
    4. 168 |
  4. Rotate rectangle by 55 degrees towards the direction 169 | {"x": 0.55, "y": 0.37, "z": 0.74} 170 | and draw it using perspective projection 171 |
    5. 172 | 173 |
174 |
175 | 177 | 178 | 179 | 181 | 182 | 183 | 184 | 185 | 186 | -------------------------------------------------------------------------------- /procs/theme/image/math/polarPoint.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | 21 | 25 | 29 | 33 | 34 | 35 | 59 | 68 | 69 | 71 | 72 | 74 | image/svg+xml 75 | 77 | 78 | 79 | 80 | 81 | 86 | r sin(θ) 99 | r cos(θ) 111 | 117 | 122 | 127 | 132 | 137 | 143 | r 155 | θ 168 | x 180 | y 192 | p1 = (r, θ) 204 | 205 | 206 | -------------------------------------------------------------------------------- /procs/theme/image/math/trig.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | 21 | 44 | 49 | 50 | 52 | 53 | 55 | image/svg+xml 56 | 58 | 59 | 60 | 61 | 62 | 67 | 72 | 83 | A 94 | B 105 | C 116 | a 127 | c 138 | b 149 | 155 | θ 166 | sin(θ) = a / b 177 | cos(θ) = c / b 188 | tan(θ) = a / c 199 | 200 | 201 | -------------------------------------------------------------------------------- /procs/theme/image/processing/sinewave.svg: -------------------------------------------------------------------------------- 1 | 2 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | -------------------------------------------------------------------------------- /procs/theme/image/math/derivSecant.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | 21 | 44 | 49 | 50 | 52 | 53 | 55 | image/svg+xml 56 | 58 | 59 | 60 | 61 | 62 | 67 | 72 | 77 | 83 | 88 | 93 | x 106 | f(x) 117 | h 129 | f(x+h) 140 | 145 | 150 | 156 | 163 | x 176 | f(x+h) 187 | h → 0 198 | x + h 209 | 210 | 211 | -------------------------------------------------------------------------------- /procs/theme/css/prism.css: -------------------------------------------------------------------------------- 1 | /* PrismJS 1.18.0 2 | https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+abap+abnf+actionscript+ada+antlr4+apacheconf+apl+applescript+aql+arduino+arff+asciidoc+asm6502+aspnet+autohotkey+autoit+bash+basic+batch+bbcode+bison+bnf+brainfuck+brightscript+bro+c+csharp+cpp+cil+coffeescript+cmake+clojure+crystal+csp+css-extras+d+dart+diff+django+dns-zone-file+docker+ebnf+eiffel+ejs+elixir+elm+etlua+erb+erlang+fsharp+firestore-security-rules+flow+fortran+ftl+gcode+gdscript+gedcom+gherkin+git+glsl+gml+go+graphql+groovy+haml+handlebars+haskell+haxe+hcl+http+hpkp+hsts+ichigojam+icon+inform7+ini+io+j+java+javadoc+javadoclike+javastacktrace+jolie+jq+jsdoc+js-extras+js-templates+json+jsonp+json5+julia+keyman+kotlin+latex+latte+less+lilypond+liquid+lisp+livescript+lolcode+lua+makefile+markdown+markup-templating+matlab+mel+mizar+monkey+moonscript+n1ql+n4js+nand2tetris-hdl+nasm+neon+nginx+nim+nix+nsis+objectivec+ocaml+opencl+oz+parigp+parser+pascal+pascaligo+pcaxis+perl+php+phpdoc+php-extras+plsql+powershell+processing+prolog+properties+protobuf+pug+puppet+pure+python+q+qml+qore+r+jsx+tsx+renpy+reason+regex+rest+rip+roboconf+robotframework+ruby+rust+sas+sass+scss+scala+scheme+shell-session+smalltalk+smarty+solidity+soy+sparql+splunk-spl+sqf+sql+stylus+swift+tap+tcl+textile+toml+tt2+turtle+twig+typescript+t4-cs+t4-vb+t4-templating+vala+vbnet+velocity+verilog+vhdl+vim+visual-basic+wasm+wiki+xeora+xojo+xquery+yaml+zig&plugins=line-highlight+line-numbers+show-language+highlight-keywords+inline-color+command-line+normalize-whitespace+toolbar+download-button+diff-highlight */ 3 | /** 4 | * prism.js default theme for JavaScript, CSS and HTML 5 | * Based on dabblet (http://dabblet.com) 6 | * @author Lea Verou 7 | */ 8 | 9 | code[class*="language-"], 10 | pre[class*="language-"] { 11 | color: black; 12 | background: none; 13 | text-shadow: 0 1px white; 14 | font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace; 15 | font-size: 1em; 16 | text-align: left; 17 | white-space: pre; 18 | word-spacing: normal; 19 | word-break: normal; 20 | word-wrap: normal; 21 | line-height: 1.5; 22 | 23 | -moz-tab-size: 4; 24 | -o-tab-size: 4; 25 | tab-size: 4; 26 | 27 | -webkit-hyphens: none; 28 | -moz-hyphens: none; 29 | -ms-hyphens: none; 30 | hyphens: none; 31 | } 32 | 33 | pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection, 34 | code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection { 35 | text-shadow: none; 36 | background: #b3d4fc; 37 | } 38 | 39 | pre[class*="language-"]::selection, pre[class*="language-"] ::selection, 40 | code[class*="language-"]::selection, code[class*="language-"] ::selection { 41 | text-shadow: none; 42 | background: #b3d4fc; 43 | } 44 | 45 | @media print { 46 | code[class*="language-"], 47 | pre[class*="language-"] { 48 | text-shadow: none; 49 | } 50 | } 51 | 52 | /* Code blocks */ 53 | pre[class*="language-"] { 54 | padding: 1em; 55 | margin: .5em 0; 56 | overflow: auto; 57 | } 58 | 59 | :not(pre) > code[class*="language-"], 60 | pre[class*="language-"] { 61 | background: #f5f2f0; 62 | } 63 | 64 | /* Inline code */ 65 | :not(pre) > code[class*="language-"] { 66 | padding: .1em; 67 | border-radius: .3em; 68 | white-space: normal; 69 | } 70 | 71 | .token.comment, 72 | .token.prolog, 73 | .token.doctype, 74 | .token.cdata { 75 | color: slategray; 76 | } 77 | 78 | .token.punctuation { 79 | color: #999; 80 | } 81 | 82 | .token.namespace { 83 | opacity: .7; 84 | } 85 | 86 | .token.property, 87 | .token.tag, 88 | .token.boolean, 89 | .token.number, 90 | .token.constant, 91 | .token.symbol, 92 | .token.deleted { 93 | color: #905; 94 | } 95 | 96 | .token.selector, 97 | .token.attr-name, 98 | .token.string, 99 | .token.char, 100 | .token.builtin, 101 | .token.inserted { 102 | color: #690; 103 | } 104 | 105 | .token.operator, 106 | .token.entity, 107 | .token.url, 108 | .language-css .token.string, 109 | .style .token.string { 110 | color: #9a6e3a; 111 | background: hsla(0, 0%, 100%, .5); 112 | } 113 | 114 | .token.atrule, 115 | .token.attr-value, 116 | .token.keyword { 117 | color: #07a; 118 | } 119 | 120 | .token.function, 121 | .token.class-name { 122 | color: #DD4A68; 123 | } 124 | 125 | .token.regex, 126 | .token.important, 127 | .token.variable { 128 | color: #e90; 129 | } 130 | 131 | .token.important, 132 | .token.bold { 133 | font-weight: bold; 134 | } 135 | .token.italic { 136 | font-style: italic; 137 | } 138 | 139 | .token.entity { 140 | cursor: help; 141 | } 142 | 143 | pre[data-line] { 144 | position: relative; 145 | padding: 1em 0 1em 3em; 146 | } 147 | 148 | .line-highlight { 149 | position: absolute; 150 | left: 0; 151 | right: 0; 152 | padding: inherit 0; 153 | margin-top: 1em; /* Same as .prism’s padding-top */ 154 | 155 | background: hsla(24, 20%, 50%,.08); 156 | background: linear-gradient(to right, hsla(24, 20%, 50%,.1) 70%, hsla(24, 20%, 50%,0)); 157 | 158 | pointer-events: none; 159 | 160 | line-height: inherit; 161 | white-space: pre; 162 | } 163 | 164 | .line-highlight:before, 165 | .line-highlight[data-end]:after { 166 | content: attr(data-start); 167 | position: absolute; 168 | top: .4em; 169 | left: .6em; 170 | min-width: 1em; 171 | padding: 0 .5em; 172 | background-color: hsla(24, 20%, 50%,.4); 173 | color: hsl(24, 20%, 95%); 174 | font: bold 65%/1.5 sans-serif; 175 | text-align: center; 176 | vertical-align: .3em; 177 | border-radius: 999px; 178 | text-shadow: none; 179 | box-shadow: 0 1px white; 180 | } 181 | 182 | .line-highlight[data-end]:after { 183 | content: attr(data-end); 184 | top: auto; 185 | bottom: .4em; 186 | } 187 | 188 | .line-numbers .line-highlight:before, 189 | .line-numbers .line-highlight:after { 190 | content: none; 191 | } 192 | 193 | pre[class*="language-"].line-numbers { 194 | position: relative; 195 | padding-left: 3.8em; 196 | counter-reset: linenumber; 197 | } 198 | 199 | pre[class*="language-"].line-numbers > code { 200 | position: relative; 201 | white-space: inherit; 202 | } 203 | 204 | .line-numbers .line-numbers-rows { 205 | position: absolute; 206 | pointer-events: none; 207 | top: 0; 208 | font-size: 100%; 209 | left: -3.8em; 210 | width: 3em; /* works for line-numbers below 1000 lines */ 211 | letter-spacing: -1px; 212 | border-right: 1px solid #999; 213 | 214 | -webkit-user-select: none; 215 | -moz-user-select: none; 216 | -ms-user-select: none; 217 | user-select: none; 218 | 219 | } 220 | 221 | .line-numbers-rows > span { 222 | pointer-events: none; 223 | display: block; 224 | counter-increment: linenumber; 225 | } 226 | 227 | .line-numbers-rows > span:before { 228 | content: counter(linenumber); 229 | color: #999; 230 | display: block; 231 | padding-right: 0.8em; 232 | text-align: right; 233 | } 234 | 235 | div.code-toolbar { 236 | position: relative; 237 | } 238 | 239 | div.code-toolbar > .toolbar { 240 | position: absolute; 241 | top: .3em; 242 | right: .2em; 243 | transition: opacity 0.3s ease-in-out; 244 | opacity: 0; 245 | } 246 | 247 | div.code-toolbar:hover > .toolbar { 248 | opacity: 1; 249 | } 250 | 251 | /* Separate line b/c rules are thrown out if selector is invalid. 252 | IE11 and old Edge versions don't support :focus-within. */ 253 | div.code-toolbar:focus-within > .toolbar { 254 | opacity: 1; 255 | } 256 | 257 | div.code-toolbar > .toolbar .toolbar-item { 258 | display: inline-block; 259 | } 260 | 261 | div.code-toolbar > .toolbar a { 262 | cursor: pointer; 263 | } 264 | 265 | div.code-toolbar > .toolbar button { 266 | background: none; 267 | border: 0; 268 | color: inherit; 269 | font: inherit; 270 | line-height: normal; 271 | overflow: visible; 272 | padding: 0; 273 | -webkit-user-select: none; /* for button */ 274 | -moz-user-select: none; 275 | -ms-user-select: none; 276 | } 277 | 278 | div.code-toolbar > .toolbar a, 279 | div.code-toolbar > .toolbar button, 280 | div.code-toolbar > .toolbar span { 281 | color: #bbb; 282 | font-size: .8em; 283 | padding: 0 .5em; 284 | background: #f5f2f0; 285 | background: rgba(224, 224, 224, 0.2); 286 | box-shadow: 0 2px 0 0 rgba(0,0,0,0.2); 287 | border-radius: .5em; 288 | } 289 | 290 | div.code-toolbar > .toolbar a:hover, 291 | div.code-toolbar > .toolbar a:focus, 292 | div.code-toolbar > .toolbar button:hover, 293 | div.code-toolbar > .toolbar button:focus, 294 | div.code-toolbar > .toolbar span:hover, 295 | div.code-toolbar > .toolbar span:focus { 296 | color: inherit; 297 | text-decoration: none; 298 | } 299 | 300 | span.inline-color { 301 | display: inline-block; 302 | height: 1.333ch; 303 | width: 1.333ch; 304 | margin: 0 .333ch; 305 | box-sizing: border-box; 306 | border: 1px solid white; 307 | outline: 1px solid black; 308 | } 309 | 310 | .command-line-prompt { 311 | border-right: 1px solid #999; 312 | display: block; 313 | float: left; 314 | font-size: 100%; 315 | letter-spacing: -1px; 316 | margin-right: 1em; 317 | pointer-events: none; 318 | 319 | -webkit-user-select: none; 320 | -moz-user-select: none; 321 | -ms-user-select: none; 322 | user-select: none; 323 | } 324 | 325 | .command-line-prompt > span:before { 326 | color: #999; 327 | content: ' '; 328 | display: block; 329 | padding-right: 0.8em; 330 | } 331 | 332 | .command-line-prompt > span[data-user]:before { 333 | content: "[" attr(data-user) "@" attr(data-host) "] $"; 334 | } 335 | 336 | .command-line-prompt > span[data-user="root"]:before { 337 | content: "[" attr(data-user) "@" attr(data-host) "] #"; 338 | } 339 | 340 | .command-line-prompt > span[data-prompt]:before { 341 | content: attr(data-prompt); 342 | } 343 | 344 | pre.diff-highlight > code .token.deleted:not(.prefix), 345 | pre > code.diff-highlight .token.deleted:not(.prefix) { 346 | background-color: rgba(255, 0, 0, .1); 347 | color: inherit; 348 | display: block; 349 | } 350 | 351 | pre.diff-highlight > code .token.inserted:not(.prefix), 352 | pre > code.diff-highlight .token.inserted:not(.prefix) { 353 | background-color: rgba(0, 255, 128, .1); 354 | color: inherit; 355 | display: block; 356 | } 357 | 358 | -------------------------------------------------------------------------------- /procs/projects/notes.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Projects 8 | 9 | 10 | 11 | 12 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | -------------------------------------------------------------------------------- /procs/solutions/math/calculus.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Calculus Solutions 7 | 8 | 9 | 10 | 11 | 12 |
13 | 30 |
31 |
32 | 
 33 | 
 34 | der :: (Real -> Real) -> Real -> Real -> Real
 35 | der f x h = (f(x + h) - f(x)) / h
 36 | integ :: (Real -> Real) -> [Real] -> Real -> Real -> Real
 37 | 
 38 | integ f a:args stepsize counter 
 39 |     | null (a:args) = counter
 40 |     | otherwise = integ f args stepsize (f(a) * stepsize)
 41 | 
 42 | -- answer 1
 43 | f1 :: Real -> Real
 44 | f2 :: Real -> Real
 45 | c1 :: Real -> Real
 46 | f1 x = x + 3
 47 | f2 x = x / 8
 48 | c1 x = (f1 x) + (f2 x)
 49 | sumCheck :: (Real -> Real) -> (Real -> Real) -> Real -> Bool
 50 | 
 51 | sumCheck f g v = (der c1 v 0.1 ) == (
 52 |     (der f1 v 0.1) + (der f2 v 0.1)
 53 |     )
 54 | 
 55 | 
 56 |
57 |
58 |
59 | 
 60 | 
 61 | def der(f: Callable, x: float, h: float):
 62 |     v1 = f(x+h)
 63 |     v2 = f(x)
 64 |     return (v1 - v2) / h
 65 | 
 66 | # Answer 1
 67 | def f1(x): return x + 3
 68 | def f2(x): return x / 8
 69 | def c1(x): return f1(x) + f2(x)
 70 | def sumCheck(f1, f2, v):
 71 |     derc = der(c1, v, 0.1)
 72 |     derf1 = der(f1, v, 0.1)
 73 |     derf2 = der(f2, v, 0.1)
 74 |     return derc == (derf1 + derf2)
 75 | 
 76 | # Answer 2
 77 | def area(arg, f1, f2): return f1(arg) - f2(arg)
 78 | 
 79 | def integ(f: Callable, args: list, stepsize: float):
 80 |     counter = 0
 81 |     for a in args:
 82 |         v = f(a)
 83 |         counter += v*stepsize
 84 |     return counter
 85 | 
 86 | # answer 2
 87 | def f(x): return x + 3
 88 | def g(x): return 12 - 2 * x
 89 | 
 90 | def lined(v1, v2):
 91 |     return math.sqrt( (v1[0] - v2[0]) ** 2 + (v1[1] - v2[1]) ** 2 )
 92 | 
 93 | def areaTriangle(fline1=f, fline2=g, v1=(1,4), v2=(4, 4), v3=(3,6)): 
 94 |     "compute area of triangle using integral"
 95 |     #6     v3
 96 |     #5
 97 |     #4 v1  _ v2 
 98 |     #3
 99 |     #2
100 |     #1  
101 |     #0 1 2 3 4 5 6 
102 |     hb = (3, 4)
103 |     leftArea = 0
104 |     for x in range(v1[0], hb[0]+1):
105 |         leftArea += area(x, fline1, fline2)
106 |     rightArea = 0
107 |     for x in range(hb[0], v2[0]+1):
108 |         rightArea += area(x, fline1, fline2)
109 |     return leftArea + rightArea
110 | 
111 | # answer 3
112 | def rect_area(p1, w, f=lambda x: x+5, g=lambda x: x+13):
113 |     R = 0
114 |     for x in range(p[0], p[0] + w+1):
115 |         R += area(x, f, g)
116 |     return R
117 | 
118 | # answer 4
119 | def volume(p1, w, h, l):
120 |     xfin = p1[0] + w
121 |     yfin = p1[1] + h
122 |     zfin = p1[1] + z
123 |     zone1 = 0
124 |     for i in range(p1[0], xfin + 1):
125 |         zone1 += 1
126 |     zone2 = 0
127 |     for i in range(p1[1], yfin + 1):
128 |         zone2 += 1
129 |     zone3 = 0
130 |     for i in range(p1[2], zfin + 1):
131 |         zone3 += 1
132 |     return zone1 * zone2 * zone3
133 | 
134 | 
135 |
136 |
137 |
138 | 
139 | 
140 | float f(float arg);
141 | 
142 | float der(float x, float h)
143 | {
144 |     float v1 = f(x+h);
145 |     float v2 = f(x);
146 |     return (v1 - v2) / h;
147 | }
148 | float integ(std::vector args, float stepsize)
149 | {
150 |     float counter = 0;
151 |     for (int i=0; i < vector.size(); i++)
152 |       {
153 |         counter += f(vector[i]) * stepsize;
154 |       }
155 |     return counter;
156 | }
157 | 
158 |
159 |
160 |
161 | 
162 | 
163 | proc f(arg: float): float
164 | 
165 | proc der(x: float, h: float): float =
166 |     let v1 = f(x+h)
167 |     let v2 = f(x)
168 |     return (v1 - v2) / h
169 | 
170 | proc integ(args: seq[float], step: float): float =
171 |     var counter = 0
172 |     for a in args:
173 |         v = f(a) * step
174 |         counter += v
175 |     return counter
176 | 
177 | 
178 |
179 |
180 |
181 | 
182 | 
183 | f: function [a] [return a]
184 | der: function[f x h] [
185 |     v1: f [x+h]
186 |     v2: f [x]
187 |     res: v1-v2
188 |     return res / h
189 | ]
190 | ;; answer 1
191 | f1: function [x] [return x + 3]
192 | f2: function [x] [return x / 8]
193 | c1: function [x] [return [f1 x] + [f2 x]] 
194 | sumCheck: function [x] [
195 |     derc: der [c1 x 0.1] 
196 |     derf1: der [f1 x 0.1] 
197 |     derf2: der [f2 x 0.1] 
198 |     return derc == [derf1 + derf2]
199 | ]
200 | 
201 |
202 |
203 |
204 |
205 | 206 |
    207 |
  1. 208 |
    209 |

    210 | Write small programs to test the rules of 211 | differentiation. Did you notice anything strange ? 212 |

    213 | 214 |
    215 |
    2. 216 |
  2. 217 |
    218 |

    219 | Write a program to compute the area of a triangle 220 | using integral function defined above. The area of the 221 | triangle is computed in two parts. Left Area and Right 222 | Area, where you compute left section of a 223 | perpendicular to the base of a triangle, and then the 224 | right. Any area between zones is computed as a 225 | difference in integral. \( 226 | f(x) = x + 3 \hspace{1em} g(x) = x * 3 +8 227 | \hspace{1em} \int_{min_x}^{max_x} (f(x) - g(x)) \times 228 | dx 229 | \) 230 | Vertices of triangle: (1, 4) (4,4) (3, 6) 231 | two equations of sides: \( f(x) = x+3 \hspace{1em} 232 | g(x) = 12 - 2*x\) 233 |

    234 |
    235 |
    3. 236 |
  3. 237 |
    238 |

    239 | Given the top left corner of the rectangle (1, 3) and 240 | width 13, height 46, compute the area of the rectangle 241 | using the integral. 242 |

    243 |
    244 |
    4. 245 |
  4. 246 |
    247 |

    248 | Write a program to compute the volume of cuboid. Given 249 | a corner p1 (x,y,z), width, height, length. 250 | Volume is \( w \times h \times l \) w, width, h, 251 | height, l, length. 252 |

    253 | 254 |
    255 |
    5. 256 | 257 | 258 |
259 | 261 | 262 | 263 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | -------------------------------------------------------------------------------- /procs/solutions/math/primitives.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Geometric Primitive Solutions 7 | 8 | 9 | 10 | 11 | 12 |
13 | 30 |
31 |
32 | 
 33 | 
 34 | 
 35 | 
 36 |
37 |
38 |
39 | 
 40 | 
 41 | # common to all
 42 | def make_canvas(width: int, height: int):
 43 |     canvas = [[0 for w in range(width)] for h in range(h)]
 44 |     return canvas
 45 | 
 46 | import math
 47 | 
 48 | # normaliz a vector
 49 | def normalize(v: (int, int)):
 50 |     #
 51 |     vx2 = v[0] ** 2
 52 |     vy2 = v[1] ** 2
 53 |     vr = math.sqrt(vx2 + vy2)
 54 |     return (v[0] / vr, v[1] / vr)
 55 | 
 56 | def place_rect_on_canvas(width: int, height: int,
 57 |     topLeft: (int, int), canvas):
 58 |     w, h = topLeft
 59 |     wfin = w + width # col fin
 60 |     hfin = h + height # row fin
 61 |     for r in range(len(canvas)):
 62 |         if r == hfin or r == h:
 63 |             for c in range(len(row)):
 64 |                 if c ≤ wfin and c ≥ w:
 65 |                     canvas[r][c] = 1
 66 |         elif r ≤ hfin and r ≥ h:
 67 |             canvas[r][w] = 1
 68 |             canvas[r][wfin] = 1
 69 | 
 70 | # Answer 1
 71 | def fill_rect_on_canvas(width: int, height: int,
 72 |     topLeft: (int, int), canvas):
 73 |     ""
 74 |     w, h = topLeft
 75 |     wfin = w + width # col fin
 76 |     hfin = h + height # row fin
 77 |     for r in range(len(canvas)):
 78 |         if r ≤ hfin and r ≥ h:
 79 |             row = canvas[r]
 80 |             for c in range(len(row)):
 81 |                 if c ≤ wfin and c ≥ w:
 82 |                     canvas[r][c] = 1
 83 |     return canvas
 84 | 
 85 | # generic line drawing
 86 | def draw_line_generic(v1, v2):
 87 |     x1, y1 = v1
 88 |     x2, y2 = v2
 89 |     deltax = x1 - x2
 90 |     deltay = y1 - y2
 91 | 
 92 |     xaxis_dir = 1
 93 |     if deltax > 0:
 94 |         xaxis_dir = 1
 95 |     else:
 96 |         xaxis_dir = -1
 97 | 
 98 |     yaxis_dir = 1
 99 |     if deltay > 0:
100 |         yaxis_dir = 1
101 |     else:
102 |         yaxis_dir = -1
103 | 
104 |     deltax = abs(deltax)
105 |     deltay = abs(deltay)
106 | 
107 |     if deltax > deltay:
108 |         p1x, p1y, p2x, p2y = xaxis_dir, 0, 0, yaxis_dir
109 |     else:
110 |         deltax, deltay = deltay, deltax
111 |         p1x, p1y, p2x, p2y = 0, yaxis_dir, xaxis_dir, 0
112 | 
113 |     err = 2 * deltay - deltax
114 |     yval = 0
115 |     coords = []
116 |     for x in range(deltax + 1):
117 |         xcoord = x1 + x*p1x + yval * p2x
118 |         ycoord = y1 + x*p1y + yval * p2y
119 |         coords.append([xcoord, ycoord])
120 |         if err >= 0:
121 |             yval += 1
122 |             err = err - 2 * deltax
123 |         err += 2 * deltay
124 |     return coords
125 | 
126 | 
127 | # Answer 2
128 | 
129 | # line v2 to v1:
130 | # 10 = 5m + c
131 | # 16 = 3m + c
132 | # 6 = -2m
133 | # m = -3
134 | # c = 25
135 | 
136 | # line v2 to v3:
137 | # 16 = 3m + c
138 | # 13 = 8m + c
139 | # -3 = 5m
140 | # m = -3 / 5
141 | # c = 16 + 3/5
142 | 
143 | # line v3 to v1:
144 | # 10 = 5m + c
145 | # 13 = 8m + c
146 | # 3 = 3m
147 | # m = 1
148 | # c = 5
149 | 
150 | def draw_line(v1, v2, lineq: lambda, coords):
151 |     #
152 |     for x in range(v1[0], v2[0]+1):
153 |         y = lineq(x)
154 |         coords.append([x, y])
155 |     return coords
156 | 
157 | def draw_triangle_on_canvas(v1=(5, 10),
158 |     v2=(3, 16), v3=(8, 13), canvas):
159 |     # line v1
160 |     #
161 |     def lineq1(x): return -3 * x + 25
162 |     def lineq2(x): return round((-3 / 5) * x + (16 * 3/5))
163 |     def lineq3(x): return x + 5
164 |     coords = []
165 |     draw_line(v2, v1, lineq1, coords)
166 |     draw_line(v2, v3, lineq2, coords)
167 |     draw_line(v1, v3, lineq3, coords)
168 |     for coord in coords:
169 |         x, y = coord
170 |         canvas[x][y] = 1
171 |     return canvas
172 | 
173 | # Answer 3
174 | def find_drawable(row):
175 |     indices = []
176 |     for i in range(len(row)):
177 |         if row[i] == 1:
178 |             indices.append(i)
179 |     return indices
180 | 
181 | def fill_triangle_on_canvas(v1=(5, 10),
182 |     v2=(3, 16), v3=(8, 13), canvas):
183 |     canvas_triangle = draw_triangle_on_canvas(v1, v2, v3, canvas)
184 |     for r, row in enumerate(canvas_triangle):
185 |         indices = find_drawable(row)
186 |         if indices:
187 |             for col in range(indices[0], indices[-1]):
188 |                 canvas_triangle[r][col] = 1
189 |     return canvas_triangle
190 | 
191 | # Answer 4
192 | def new_tip(v1, v2, factor):
193 |     vec1diff = (v1[0] - v2[0], v1[1] - v2[1])
194 |     vec1diff = (vec1diff[0] * factor, vec1diff[1] * factor)
195 |     return (v2[0] + vec1diff[0], v2[1] + vec1diff[1])
196 | 
197 |     
198 | def scale_triangle(v1=(5, 10), factor=2,
199 |     v2=(3, 16), v3=(8, 13), canvas):
200 |     #
201 |     newv1 = new_tip(v1, v2, factor)
202 |     newv2 = new_tip(v3, v2, factor)
203 |     newv3 = new_tip(v1, v3, factor)
204 |     return draw_triangle_on_canvas(newv1, newv2, newv3, canvas)
205 | 
206 | # Answer 5
207 | def matmul(mat1, mat2):
208 |     # create result matrix
209 |     res = [[0 for i in mat2[0]] for k in mat1]
210 |     rowM1 = len(mat1)
211 |     colM1 = len(mat1[0])
212 |     rowM2 = len(mat2)
213 |     colM2 = len(mat2[0])
214 |     for i in range(rowM1):
215 |         for j in range(colM2):
216 |             for p in range(colM1):
217 |                 res[i][j] += mat1[i][p] * mat2[p][j]
218 |     return res
219 | 
220 | def mat2vec(mat, vec):
221 |     ""
222 |     res = [[0 for i in vec] for k in mat]
223 |     rowM = len(mat)
224 |     colM = len(mat[0])
225 |     veclen = len(vec)
226 |     for i in range(rowM):
227 |         for j in range(veclen):
228 |             for p in range(colM):
229 |                 res[i][j] += mat[i][p] * vec[j]
230 |     return res
231 | 
232 | 
233 | def rotate_vert(v, angle):
234 |     rad = math.radians(angle)
235 |     mat = [[math.cos(rad), - math.sin(rad), 0],
236 |         [math.sin(rad), - math.cos(rad), 0],
237 |         [0, 0, 1]]
238 |     augmented_vec = [v[0], v[1], 1]
239 |     return mat2vec(mat, v)
240 | 
241 | def rotate_triangle(v1=(5, 10), factor=2,
242 |     v2=(3, 16), v3=(8, 13), angle, canvas):
243 |     v1r = rotate_vert(v1, angle)
244 |     v2r = rotate_vert(v2, angle)
245 |     v3r = rotate_vert(v3, angle)
246 |     line1c = draw_line_generic(v1r, v2r)
247 |     line2c = draw_line_generic(v2r, v3r)
248 |     line3c = draw_line_generic(v3r, v1r)
249 |     for coord in line1c + line2c + line3c:
250 |         x, y = coord
251 |         canvas[x][y] = 1
252 |     return canvas
253 | 
254 | 
255 | def row_to_str(row: list):
256 |     rstr = ""
257 |     for r in row:
258 |         if r == 0:
259 |             rstr += " "
260 |         else:
261 |             rstr += "*"
262 |     return rstr
263 | 
264 | def canvas_to_string(canvas):
265 |     ""
266 |     cstr = ""
267 |     for row in canvas:
268 |         rstr = row_to_str(row)
269 |         cstr += rstr + "\n"
270 |     return cstr
271 | 
272 | 
273 |
274 |
275 |
276 | 
277 | 
278 | 
279 | 
280 |
281 |
282 |
283 | 
284 | 
285 | 
286 | 
287 |
288 |
289 |
290 |
291 | 292 |
    293 |
  1. 294 |
    295 |

    296 | Fill two rectangles with star *. Rectangle width: 70 297 | height: 3. First rectangle top left corner (x: 0, y: 0). 298 | Second rectangle top left corner (x: 0, y: 20). Save 299 | the file. 300 | 301 |

    302 |
    303 |
    2. 304 |
  2. 305 |
    306 |

    307 | Draw a triangle using * to canvas whose vertices are: 308 | (5, 10), (3, 16), (8, 13). Hint, parametric 309 | representation of 2d lines. 310 |

    311 | 312 |
    313 |
    3. 314 |
  3. 315 |
    316 |

    317 | Fill the triangle using * to canvas whose vertices are: 318 | (5, 10), (3, 16), (8, 13). Hint, slope intercept 319 | representation of 2d lines. 320 |

    321 |
    322 |
    4. 323 |
  4. 324 |
    325 |

    326 | Scale the size of the triangle with the vertices 327 | mentioned above by 2 328 |

    329 |
    330 |
    5. 331 |
  5. 332 |
    333 |

    334 | Rotate the triangle 45 degrees. 335 |

    336 |
    337 |
    6. 338 | 339 |
340 | 342 | 343 | 344 | 346 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | -------------------------------------------------------------------------------- /procs/theme/image/math/triangleRelations.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | 21 | 44 | 49 | 50 | 52 | 53 | 55 | image/svg+xml 56 | 58 | 59 | 60 | 61 | 62 | 67 | 72 | 77 | A 88 | B 99 | C 110 | P 121 | h 132 | b 143 | c 154 | k 165 | m 176 | 187 | 193 | 199 | β 210 | ρ 221 | ε 232 | θ 243 | 249 | 255 | (a) / sin(α)= c / sin(θ)= b / sin(β) 274 | b² = a² + c² - 2 ac cos(β) 285 | } 297 | law of sines 308 | } 322 | law of cosines 333 | a = k+m 344 | α = ρ+ε 356 | 361 | 362 | 363 | -------------------------------------------------------------------------------- /procs/formation/notes.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | Image Formation Notes 9 | 10 |
11 |
12 | 15 |
16 |
17 |
18 |

Scattering

19 |
20 |

Problem Statement

21 |

22 | What happens when light hits on the surface of an object ? 23 |

24 |
25 |

Description

26 |

27 | When thinking about light scattering, it is better to let the model 28 | guide the discourse rather than the inverse. Light scattering 29 | is modeled as 30 | bidirectional reflectance distribution 31 | function ( BRDF ). It describes how 33 | much wavelength incoming to a relative surface coordinate is 34 | emitted. The function can be written as \( 35 | f_r(\theta_{\text{incoming}}, \phi_{\text{incoming}}, 36 | \theta_{\text{emitted}}, \phi_{\text{emitted}}; \lambda) 37 | \) where \(\phi\) and \( \theta \) are spherical coordinates 38 | for the incident flux, meaning they are the angles in which 39 | the flux is arriving and emitted. 40 |

41 |

42 | It is a reciprocal function where you can change the roles of the 43 | incoming and emitted angles and you would obtain the same value 44 | anyway due to the physics of light transport. The full model 45 | has two parts: \[ 46 | L_{r}(\hat{v};\lambda) = \int L_i(\theta_i; \lambda) 47 | \hspace{0.5em} 48 | f_r(\theta_i, \phi_i, \theta_e, \phi_e; \lambda)\hspace{0.5em} 49 | max(0, \cos(\theta_i))\hspace{0.5em} d \theta_i \phi_i 50 | \] 51 | 52 | Though this equation is particularly important for rendering a 53 | scene, its explanation is beyond the scope of the course of 54 | this year. It might be treated in the following years. However 55 | here is a link 56 | that explains how rendering equation works. 57 |

58 |

59 | Phong Shading Model: \[ 60 | I_{\lambda} = I_{a\lambda}k_a O_{d\lambda} + 61 | f_{att}I_{p\lambda}[k_d O_{d\lambda} (\hat{N} \cdot \hat{L}) + k_s 62 | (\hat{R} \cdot \hat{V})^n] \hspace{1em} 63 | \hat{R} \cdot \hat{V} = (2\hat{N} (\hat{N} \cdot \hat{L}) - 64 | \hat{L} ) \cdot \hat{V} 65 | \] 66 |

67 | 68 | 69 |
70 | Phong Model 71 |
72 |
73 | Here is the components of the model 74 |
75 |
76 |
\(I_{\lambda}\)
77 |
78 | Light intensity for channel \(\lambda\). In 79 | practice this is the value for one of your color 80 | channels R,G, or B. In most cases it is a 81 | normalized value between 0 and 1.0, we interpolate 82 | it to a value between 0 and 255. 83 |
84 |
85 |
86 |
\(I_{a\lambda}\)
87 |
88 | Ambient light intensity for the channel 89 | \(\lambda\). The amount of light in the 90 | environment. 91 |
92 |
93 |
94 |
\(k_a\)
95 |
96 | Ambient light coefficient. This help us to control 97 | how much the ambient light should effect the 98 | overall color of the object. 99 |
100 |
101 |
102 |
\(O_{d\lambda}\)
103 |
104 | Object diffuse coefficient. It is a material 105 | property of the object. It models how much the 106 | object reacts to the wavelength \(\lambda\) of the 107 | light. 108 |
109 |
110 |
111 |
\(f_{att}\)
112 |
113 | Attenuation value. Since light reduces its 114 | intensity as it travels from its caster to the 115 | material that scatters it. If this would not be 116 | the case, we would not be able to distinguish 117 | objects that emit same color and that are 118 | equidistant to us. Their distance to the light 119 | source changes the attenuation factor of the light 120 | rays that scatter on them, which in turn reflects 121 | as an intensity change, that intensity change help 122 | us to distinguish the objects. In most cases it is 123 | calculated as follows: \( 124 | f_att = \frac{1}{a_c + a_l * d + a_q * d^2} 125 | \) 126 | where \(a_c\) is constant factor, \(a_l\) is 127 | linear factor, \(a_q\) is quadratic factor. These 128 | are arbitrary factors. Constant factor is mostly 129 | 1.0. Linear and quadratic change with respect to 130 | distance. 131 |
132 |
133 |
134 |
135 | \( I_{p\lambda} \) 136 |
137 |
138 | Diffuse intensity of light. This is mostly 139 | used for incoming ray intensity. For example 1.0 140 | for the channel \(\lambda\) which is a place 141 | holder for R, G, B. 142 |
143 |
144 |
145 |
N
146 |
147 | Surface normal. 148 |
149 |
150 |
151 |
L
152 |
153 | Direction of incoming light 154 |
155 |
156 |
157 |
\(k_s\)
158 |
159 | Specular coefficient. It permits us to control how 160 | much specular radiance of the object. This is 161 | actually a material property. 162 |
163 |
164 |
165 |
\(\hat{R}\)
166 |
167 | Reflection vector. Direction to which light is 168 | reflected from the surface. Normalized. 169 |
170 |
171 |
172 |
\(\hat{V}\)
173 |
174 | Viewer vector. Direction in which the viewer is 175 | located. Normalized. 176 |
177 |
178 |
179 |
n
180 |
181 | Specular reflection exponent coefficient. 182 | Another material property. This also help us to 183 | control specularity. 184 |
185 |
186 |
187 |

188 |

189 | Phong shading model is superseded by microfacet based models but 190 | still for quick experiments it gives acceptable results, and 191 | it is easy to evaluate. The final color, final appearance, is 192 | composed of three elements: ambient, diffuse, specular. These 193 | components are controlled via coefficients. These coefficients 194 | are based on the material properties of the objects. However 195 | the problem with Phong model is that the contribution of the 196 | material properties is modeled in rather arbitrary fashion. 197 | Thus, it is difficult to explain why some value works for 198 | modeling the behavior of an object. 199 |

200 |

Code snippets

201 |
202 | 219 |
220 |
221 | 
222 | 
223 | 
224 |
225 |
226 |
227 | 
228 | 
229 | 
230 |
231 |
232 |
233 | 
234 | 
235 | 
236 |
237 |
238 |
239 | 
240 | 
241 | 
242 |
243 |
244 |
245 | 
246 | 
247 | 
248 |
249 |
250 |
251 |
252 |
253 |

Exercise

254 |
    255 |
  • 256 | Implement and test Phong model on scene. The scene 257 | contains the following: 258 |
      259 |
    • Rectangle whose vertices are: 260 |
        261 |
      • [0.0, 5.0, 0.0]
        • 262 |
      • [0.0, 1.0, 0.0]
        • 263 |
      • [8.0, 1.0, 0.0]
        • 264 |
      • [8.0, 5.0, 0.0]
        • 265 |
      266 |
      • 267 |
    • The color matrix of the rectangle is 268 | \( 269 | \pmatrix{ 270 | 10 & 120 & 120 & 120 & 86 & 132 & 200 & 250 \\ 271 | 100 & 10 & 10 & 10 & 8 & 12 & 200 & 250 \\ 272 | 120 & 10 & 130 & 130 & 132 & 32 & 100 & 150 \\ 273 | 150 & 180 & 220 & 220 & 159 & 136 & 250 & 250 274 | }\) 275 |
      • 276 |
    • 277 | Light source who is positioned at [4.0, 20.0, 278 | 4.0] and whose diffuse intensity is 255. 279 |
      • 280 |
    • Viewer who is positioned at [8.0, 12.0, 6.0]
      • 281 |
    • Attenuation factor values are 1.0, 0.7, 1.8
      • 282 |
    • Ambient intensity is 1.0
      • 283 |
    • The values for \(k_a, k_s\) are arbitrary values between 0 284 | and 1 285 |
      • 286 |
    • The value for n can be anything between 1 287 | and 800
      • 288 |
    289 |
    • 290 |
291 |
292 |
293 |

References

294 |
    295 |
  • 296 | Foley, James, Andries van Dam, Steven Feiner, John Hughes, David Skalar, Kurt Akeley, and Morgan McGuire. Computer Graphics: Principles and Practice. 3rd ed. Paris, 2013. 297 |
    • 298 |
  • 299 | 300 | Szeliski, Richard. Computer Vision: Algorithms and Applications. Texts in Computer Science. London: Springer, 2011. 301 | 302 |
    • 303 |
304 |
305 |
306 |
307 | 308 | 310 | 311 | 312 | 314 | 315 | 316 | 317 |
318 | 319 | 320 | -------------------------------------------------------------------------------- /procs/theme/image/math/xyzPoint.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 20 | 22 | 29 | 36 | 43 | 44 | 65 | 70 | 71 | 73 | 74 | 76 | image/svg+xml 77 | 79 | 80 | 82 | image/svg+xml 83 | 85 | 86 | 87 | 88 | 92 | 95 | 100 | 105 | 121 | 137 | 153 | 158 | 163 | x 175 | y 187 | z 199 | 204 | p1 217 | 223 | 227 | 232 | 237 | 242 | 247 | 252 | 262 | y 274 | x 286 | z 298 | 303 | 308 | 313 | 318 | p2 330 | x 342 | y 354 | z 366 | 367 | 368 | 369 | -------------------------------------------------------------------------------- /procs/theme/image/math/pisagor2d.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 20 | 22 | 28 | 31 | 35 | 37 | 41 | 45 | 49 | 53 | 57 | 61 | 65 | 69 | 73 | 77 | 81 | 85 | 89 | 93 | 97 | 101 | 105 | 109 | 110 | 111 | 112 | 118 | 121 | 125 | 127 | 131 | 135 | 139 | 143 | 147 | 151 | 155 | 159 | 163 | 167 | 171 | 175 | 179 | 183 | 187 | 191 | 195 | 199 | 200 | 201 | 202 | 203 | 227 | 230 | 231 | 233 | 234 | 236 | image/svg+xml 237 | 239 | 240 | 241 | 242 | 247 | 251 | 255 | 259 | 263 | 267 | 271 | 275 | 279 | 283 | 287 | 291 | 295 | 299 | 303 | 307 | 311 | 315 | 319 | 323 | 327 | 331 | x 343 | y 355 | p1=(x1,y1) 368 | * 379 | p2=(x2, y2) 390 | 395 | 400 | x1 - x2 411 | y1 - y2 423 | Δ(p1,p2) 438 | 443 | * 457 | 458 | 459 | --------------------------------------------------------------------------------