diff --git a/website/BeauSou2Index.py b/website/BeauSou2Index.py
deleted file mode 100644
index 544defd6e9c9e66e8e08901e10761a10b56bf218..0000000000000000000000000000000000000000
--- a/website/BeauSou2Index.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-#html-juergen greets doxygaehn
-
-from BeautifulSoup import BeautifulSoup
-import re,os
-
-def Links(ifile):
- doxrelpath=os.path.dirname(os.path.dirname(ifile))
- if doxrelpath.startswith('html/'):
- doxrelpath=re.sub(r'html\/','',doxrelpath,re.I)
- if not doxrelpath.endswith('/'):
- doxrelpath=doxrelpath+'/'
- ih=open(ifile,'r')
- lines=ih.readlines()
- ih.close()
- soup=BeautifulSoup(''.join(lines))
- anchors=soup('a')
- for anch in anchors:
- namespace=[]
- if anch.has_key('href'):
- yield anch
-
-def CreateClassIndex(ifile, ofile):
- classlist=[]
- doxrelpath=os.path.dirname(os.path.dirname(ifile))
- if doxrelpath.startswith('html/'):
- doxrelpath=re.sub(r'html\/','',doxrelpath,re.I)
- if not doxrelpath.endswith('/'):
- doxrelpath=doxrelpath+'/'
- for link in Links(ifile):
- m=re.search('(.*class(ost|geom).*)',link.get('href'),re.I)
- if m:
- m2=re.search(r'class([^_]*)',m.group(0))
- if m2:
- namespace=[]
- namespace.append(m2.group(1))
- p=re.compile(r'([^_]+)_1_1')
- res=p.findall(m.group(0))
- for item in res:
- if not re.search(r'class',item):
- namespace.append(item.replace(' >','>').replace('< ','<'))
- namespace.append(link.string.replace(' >','>').replace('< ','<'))
- mylink={}
- mylink['::'.join(namespace)]=m.group(0)
- classlist.append(mylink)
- oh=open(ofile,'w')
- for myclass in classlist:
- for key,value in myclass.iteritems():
- path_prefix=doxrelpath+'html/'+value+'\n'
- oh.write(key+','+path_prefix)
-
-def CreateExampleIndex(ifile, ofile):
- oh=open(ofile, 'w')
- for link in Links(ifile):
- if link.get('class')=='el':
- oh.write(link.string+','+link.get('href')+'\n')
diff --git a/website/Doxyfile b/website/Doxyfile
deleted file mode 100644
index 00c2438ae5fd73b3bee2b6c1ad738236c2a2281b..0000000000000000000000000000000000000000
--- a/website/Doxyfile
+++ /dev/null
@@ -1,259 +0,0 @@
-# Doxyfile 1.5.7
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-DOXYFILE_ENCODING = UTF-8
-PROJECT_NAME = OpenStructure
-PROJECT_NUMBER =
-OUTPUT_DIRECTORY = html/dox
-CREATE_SUBDIRS = YES
-OUTPUT_LANGUAGE = English
-BRIEF_MEMBER_DESC = NO
-REPEAT_BRIEF = YES
-ABBREVIATE_BRIEF = "The $name class" \
- "The $name widget" \
- "The $name file" \
- is \
- provides \
- specifies \
- contains \
- represents \
- a \
- an \
- the
-ALWAYS_DETAILED_SEC = NO
-INLINE_INHERITED_MEMB = NO
-FULL_PATH_NAMES = NO
-STRIP_FROM_INC_PATH =
-SHORT_NAMES = NO
-JAVADOC_AUTOBRIEF = NO
-QT_AUTOBRIEF = NO
-MULTILINE_CPP_IS_BRIEF = NO
-INHERIT_DOCS = YES
-SEPARATE_MEMBER_PAGES = NO
-TAB_SIZE = 2
-ALIASES =
-OPTIMIZE_OUTPUT_FOR_C = NO
-OPTIMIZE_OUTPUT_JAVA = YES
-OPTIMIZE_FOR_FORTRAN = NO
-OPTIMIZE_OUTPUT_VHDL = NO
-BUILTIN_STL_SUPPORT = NO
-CPP_CLI_SUPPORT = NO
-SIP_SUPPORT = NO
-IDL_PROPERTY_SUPPORT = YES
-DISTRIBUTE_GROUP_DOC = NO
-SUBGROUPING = YES
-TYPEDEF_HIDES_STRUCT = NO
-SYMBOL_CACHE_SIZE = 0
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL = YES
-EXTRACT_PRIVATE = NO
-EXTRACT_STATIC = YES
-EXTRACT_LOCAL_CLASSES = YES
-EXTRACT_LOCAL_METHODS = NO
-EXTRACT_ANON_NSPACES = NO
-HIDE_UNDOC_MEMBERS = NO
-HIDE_UNDOC_CLASSES = NO
-HIDE_FRIEND_COMPOUNDS = NO
-HIDE_IN_BODY_DOCS = NO
-INTERNAL_DOCS = NO
-CASE_SENSE_NAMES = NO
-HIDE_SCOPE_NAMES = YES
-SHOW_INCLUDE_FILES = YES
-INLINE_INFO = YES
-SORT_MEMBER_DOCS = YES
-SORT_BRIEF_DOCS = NO
-SORT_GROUP_NAMES = NO
-SORT_BY_SCOPE_NAME = NO
-GENERATE_TODOLIST = NO
-GENERATE_TESTLIST = NO
-GENERATE_BUGLIST = NO
-GENERATE_DEPRECATEDLIST= NO
-ENABLED_SECTIONS =
-MAX_INITIALIZER_LINES = 30
-SHOW_USED_FILES = YES
-SHOW_DIRECTORIES = NO
-SHOW_FILES = YES
-SHOW_NAMESPACES = YES
-FILE_VERSION_FILTER =
-LAYOUT_FILE =
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET = YES
-WARNINGS = NO
-WARN_IF_UNDOCUMENTED = NO
-WARN_IF_DOC_ERROR = YES
-WARN_NO_PARAMDOC = NO
-WARN_FORMAT = "$file:$line: $text"
-WARN_LOGFILE =
-#---------------------------------------------------------------------------
-# configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT = ../modules ../stage
-INPUT_ENCODING = UTF-8
-FILE_PATTERNS = *.hh \
- *.dox \
- *.py
-RECURSIVE = YES
-EXCLUDE_SYMLINKS = NO
-EXCLUDE_PATTERNS = *CMakeFiles* *src* *pymod* *tests* *impl*
-EXCLUDE_SYMBOLS =
-EXAMPLE_PATH = ../examples
-EXAMPLE_PATTERNS = *
-EXAMPLE_RECURSIVE = NO
-IMAGE_PATH =
-INPUT_FILTER =
-FILTER_SOURCE_FILES = NO
-#---------------------------------------------------------------------------
-# configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER = NO
-INLINE_SOURCES = NO
-STRIP_CODE_COMMENTS = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION = NO
-REFERENCES_LINK_SOURCE = NO
-USE_HTAGS = NO
-VERBATIM_HEADERS = YES
-#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX = YES
-COLS_IN_ALPHA_INDEX = 1
-IGNORE_PREFIX =
-#---------------------------------------------------------------------------
-# configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML = YES
-HTML_OUTPUT = html
-HTML_FILE_EXTENSION = .html
-HTML_HEADER = ./header.html
-HTML_FOOTER = ./footer.html
-HTML_STYLESHEET = ./stylesheet.css
-HTML_ALIGN_MEMBERS = YES
-HTML_DYNAMIC_SECTIONS = NO
-GENERATE_DOCSET = NO
-DOCSET_FEEDNAME = "Doxygen generated docs"
-DOCSET_BUNDLE_ID = org.doxygen.Project
-GENERATE_HTMLHELP = NO
-CHM_FILE =
-HHC_LOCATION =
-GENERATE_CHI = NO
-CHM_INDEX_ENCODING =
-BINARY_TOC = NO
-TOC_EXPAND = NO
-GENERATE_QHP = NO
-QCH_FILE =
-QHP_NAMESPACE = org.doxygen.Project
-QHP_VIRTUAL_FOLDER = doc
-QHG_LOCATION =
-DISABLE_INDEX = YES
-ENUM_VALUES_PER_LINE = 4
-GENERATE_TREEVIEW = NO
-TREEVIEW_WIDTH = 250
-FORMULA_FONTSIZE = 10
-#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX = NO
-LATEX_OUTPUT = latex
-LATEX_CMD_NAME = latex
-MAKEINDEX_CMD_NAME = makeindex
-COMPACT_LATEX = NO
-PAPER_TYPE = a4wide
-EXTRA_PACKAGES =
-LATEX_HEADER =
-PDF_HYPERLINKS = YES
-USE_PDFLATEX = YES
-LATEX_BATCHMODE = NO
-LATEX_HIDE_INDICES = NO
-#---------------------------------------------------------------------------
-# configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF = NO
-RTF_OUTPUT = rtf
-COMPACT_RTF = NO
-RTF_HYPERLINKS = NO
-RTF_STYLESHEET_FILE =
-RTF_EXTENSIONS_FILE =
-#---------------------------------------------------------------------------
-# configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN = NO
-MAN_OUTPUT = man
-MAN_EXTENSION = .3
-MAN_LINKS = NO
-#---------------------------------------------------------------------------
-# configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML = NO
-XML_OUTPUT = xml
-XML_SCHEMA =
-XML_DTD =
-XML_PROGRAMLISTING = YES
-#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF = NO
-#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD = NO
-PERLMOD_LATEX = NO
-PERLMOD_PRETTY = YES
-PERLMOD_MAKEVAR_PREFIX =
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING = YES
-MACRO_EXPANSION = YES
-EXPAND_ONLY_PREDEF = NO
-SEARCH_INCLUDES = YES
-INCLUDE_PATH =
-INCLUDE_FILE_PATTERNS = *.hh
-PREDEFINED =
-EXPAND_AS_DEFINED =
-SKIP_FUNCTION_MACROS = YES
-#---------------------------------------------------------------------------
-# Configuration::additions related to external references
-#---------------------------------------------------------------------------
-TAGFILES =
-GENERATE_TAGFILE =
-ALLEXTERNALS = NO
-EXTERNAL_GROUPS = YES
-PERL_PATH = /usr/bin/perl
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-CLASS_DIAGRAMS = YES
-HIDE_UNDOC_RELATIONS = YES
-HAVE_DOT = YES
-DOT_FONTNAME = Verdana
-DOT_FONTPATH =
-CLASS_GRAPH = YES
-COLLABORATION_GRAPH = YES
-GROUP_GRAPHS = YES
-UML_LOOK = NO
-TEMPLATE_RELATIONS = NO
-INCLUDE_GRAPH = NO
-INCLUDED_BY_GRAPH = NO
-CALL_GRAPH = NO
-CALLER_GRAPH = NO
-GRAPHICAL_HIERARCHY = YES
-DIRECTORY_GRAPH = NO
-DOT_IMAGE_FORMAT = png
-DOTFILE_DIRS =
-DOT_GRAPH_MAX_NODES = 50
-MAX_DOT_GRAPH_DEPTH = 2
-DOT_TRANSPARENT = NO
-DOT_MULTI_TARGETS = NO
-GENERATE_LEGEND = YES
-DOT_CLEANUP = YES
-#---------------------------------------------------------------------------
-# Configuration::additions related to the search engine
-#---------------------------------------------------------------------------
-SEARCHENGINE = YES
diff --git a/website/doxypattern.py b/website/doxypattern.py
deleted file mode 100644
index cf1bc09730ff5fc8540327ece4d3794f057ccdf7..0000000000000000000000000000000000000000
--- a/website/doxypattern.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# -*- coding: utf-8 -*-
-# class to extend inlinepatterns class to handle doxygen references by
-#inserting links(<a>) created from a previuosly compiled list of classnames
-#within ost and their relative location within the source tree
-#
-#Author Juergen Haas
-import markdown
-import re
-
-
-
-doxBRK=r'(dox|ex)\[(.*?)(\|.*?)?\]'
-DOXYREF_RE= doxBRK
-
-class DoxyRefPattern(markdown.inlinepatterns.LinkPattern):
- """ Match to a stored doxygen reference and return link element. """
- def __init__ (self, pattern, markdown_instance=None, doxyref={}, example_dict={}):
- """
- Create an instant of an inline pattern.
-
- Keyword arguments:
-
- * pattern: A regular expression that matches a pattern
-
- """
- self.pattern = pattern
- self.doxyref = doxyref
- self.example_dict=example_dict
- self.compiled_re = re.compile("^(.*?)%s(.*?)$" % pattern, re.DOTALL)
- # Api for Markdown to pass safe_mode into instance
- self.safe_mode = False
- if markdown_instance:
- self.markdown = markdown_instance
-
- def handleMatch(self, m):
- if m.group(2)=='dox':
- text = m.group(3)
- if m.group(4):
- if m.group(4).find('\|'):
- linktext=m.group(4).replace('|','')
- else:
- linktext=text
- else:
- linktext=text
- if text in self.doxyref:
- href = self.doxyref[text]
- else:
- print 'doxyref not found for', text
- return
- title= None
- return self.makeTag(href, title, linktext)
- else:
- ref=m.group(3)
- text=ref
- if m.group(4):
- text=m.group(4)[1:]
- return self.makeTag('dox/html/'+self.example_dict.get(ref, ''), None, text)
-
- def makeTag(self, href, title, text):
- el = markdown.etree.Element('a')
-
- el.set('href', self.sanitize_url(href))
-
- el.text = text
- return el
diff --git a/website/footer.html b/website/footer.html
deleted file mode 100644
index ba5dfc16f084d63e68e2f5cdc4fddd6d67ca7825..0000000000000000000000000000000000000000
--- a/website/footer.html
+++ /dev/null
@@ -1,7 +0,0 @@
- <div id="footer">
- Copyright 2008-2010 by the OpenStructure authors
- </div>
- </div>
- </div>
-</body>
-</html>
diff --git a/website/gen_site.py b/website/gen_site.py
deleted file mode 100644
index 93a266e7979a5f7476d331a38381ba649c6c133a..0000000000000000000000000000000000000000
--- a/website/gen_site.py
+++ /dev/null
@@ -1,155 +0,0 @@
-# -*- coding: utf-8 -*-
-#Authors Marco Biasini, Juergen Haas
-import markdown
-import os, re
-import codecs,shutil
-import doxypattern
-from xml import etree
-from optparse import OptionParser
-from BeauSou2Index import *
-
-
-#please use this to flag a mkdown document as incomplete:
-#> <div style="height:70px;background-color:#DD0000;border-bottom:1px solid #DDDDDD;border-top:1px solid #DDDDDD;">This document needs love!
-#
-#default path to classes.html
-#please omit the leading ''./''
-doxrelpath='html/dox/'
-CLASSES_PATH=doxrelpath+'html/classes.html'
-
-p=OptionParser()
-p.add_option('--output_dir', '-o', help='output directory',
- default='html')
-p.add_option('--input_dir', '-i', help='input directory', default='raw')
-p.add_option('--base_url', '-b',
- help='base url to be used for all relative links. if not specified, '+
- 'will be set to the output directory')
-p.add_option('--doxy_ref_file', '-d', help='file with compiled classnames, '+
- 'and corresponding doxygen page', default='index.txt')
-p.add_option('--doxy_classfile','-c',help='file, where doxygen store the'+
- 'alphabetical index',default='%s'%(CLASSES_PATH))
-p.add_option('--run_doxygen','-r',help='run doxygen with Doxyfile given as'+
- 'argument')
-opts, args=p.parse_args()
-
-if os.path.exists('../modules/scratch') or \
- os.path.exists('../modules/dng_scratch'):
- print '\nERROR ...exiting!\n\nPlease generate webpage from public checkout\n'
- os._exit(-1)
-if not opts.base_url:
- opts.base_url='file://%s' % os.path.abspath(opts.output_dir)
-scaffold_file=codecs.open('raw/scaffold.html', mode='r',
- encoding='utf8')
-SCAFFOLD=scaffold_file.read()
-
-def run_doxygen(doxyfile):
- if os.path.exists(doxyfile):
- print '\nrunning doxygen now...\n'
- cmd='doxygen %s' %(doxyfile)
- output=os.popen(cmd)
- else:
- print '\nDoxygen input file not found!\nPlease provide a valid doxygen '\
- 'input file specifying --run_doxygen YOURFILE\n'
- os._exit(-1)
-
-def load_doxy_refs():
- doxy_file=opts.doxy_ref_file
- if not os.path.isfile(doxy_file):
- print '\nWarning: Index file with doxygen classname references'\
- ' not found!\n Use -d to specify filename'\
- '(default=index.txt)\n'
- return
- doxy_refs=codecs.open(doxy_file, mode="r",
- encoding="utf8")
- lines=doxy_refs.readlines()
-
- for line in lines:
- fields=[]
- if re.search(',',line):
- fields=line.split(',')
- if len(fields)==2:
- doxy_dict[fields[0]]=fields[1]
- for line in open('examples_index.txt'):
- key, val=line.split(',')
- example_dict[key.strip()]=val.strip()
-
-def mkdown_to_html(opts, dirname, names):
-# base_dir=os.path.relpath(dirname, opts.input_dir)
- if dirname==opts.input_dir:
- base_dir=dirname[len(opts.input_dir):]
- else:
- base_dir=dirname[len(opts.input_dir)+1:]
-
- out_dir=os.path.join(opts.output_dir, base_dir)
- if out_dir.find('.svn')!=-1:
- return
- print out_dir
- if not os.path.exists(out_dir):
- os.mkdir(out_dir)
- for name in names:
- if name.endswith('.mkdown'):
- print '*- converting', name
- base_out_name=os.path.splitext(name)[0]+'.html'
- out_name=os.path.join(out_dir, base_out_name)
- full_name=os.path.join(dirname, name)
- input_file=codecs.open(os.path.join(dirname, name), mode="r",
- encoding="utf8")
- text=input_file.read()
- md=markdown.Markdown(extensions=['toc2', 'codehilite', 'meta','tables'])
- md.inlinePatterns["doxylink"] = \
- doxypattern.DoxyRefPattern(doxypattern.DOXYREF_RE,
- md,
- doxy_dict, example_dict)
- md.doc_url=os.path.join(base_dir, base_out_name)
- html=md.convert(text)
- meta=md.Meta
- toc=etree.ElementTree.tostring(md.TOC)
- title=''
- if 'title' in meta.keys():
- title=meta['title'][0]
-
- out_file=codecs.open(out_name, mode='w', encoding='utf8')
- out_file.write(SCAFFOLD % { 'CONTENT' : html, 'TITLE' : title,
- 'SITE_NAV' : toc, 'BASE' : opts.base_url})
-
-def copy_images(opts, dirname, names):
- if dirname==opts.input_dir:
- base_dir=dirname[len(opts.input_dir):]
- else:
- base_dir=dirname[len(opts.input_dir)+1:]
- out_dir=os.path.join(opts.output_dir, base_dir)
- for name in names:
- if name.endswith('.jpg') or\
- name.endswith('.JPG') or\
- name.endswith('.png') or\
- name.endswith('.PNG'):
- shutil.copy(os.path.join(dirname,name), os.path.join(out_dir,name))
-
-if not os.path.exists(opts.output_dir):
- os.mkdir(opts.output_dir)
-if not os.path.exists(os.path.join(opts.output_dir, 'css')):
- os.mkdir(os.path.join(opts.output_dir, 'css'))
-shutil.copy(os.path.join(opts.input_dir, 'css/ost.css'),
- os.path.join(opts.output_dir, 'css'))
-if opts.run_doxygen:
- run_doxygen(opts.run_doxygen)
- if os.path.exists(opts.doxy_ref_file):
- os.unlink(opts.doxy_ref_file)
-if not os.path.exists(opts.doxy_classfile):
- print 'Warning: Could not find the alphabetical index file generated\n'\
- 'by doxygen (classes.html). Please specify with -c'\
- '(default=''%s'')' %(CLASSES_PATH)
- os._exit(-2)
-else:
- print 'Found doxygen class file:',opts.doxy_classfile
-
-doxy_dict={}
-example_dict={}
-#now create the index file listing the classnames and the corresponding
-#doxygen html files for resolving the dox[ost::mol::BondHandle] mkdown tags
-if not os.path.exists(opts.doxy_ref_file):
- CreateClassIndex(opts.doxy_classfile, opts.doxy_ref_file)
- CreateExampleIndex('html/dox/html/examples.html', 'examples_index.txt')
-load_doxy_refs()
-os.path.walk(opts.input_dir, mkdown_to_html, opts)
-os.path.walk(opts.input_dir, copy_images, opts)
diff --git a/website/header.html b/website/header.html
deleted file mode 100644
index 2767659fdacde2c39434c6786a076c8174b5162b..0000000000000000000000000000000000000000
--- a/website/header.html
+++ /dev/null
@@ -1,48 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8">
- <title>$title</title>
- <link rel="stylesheet" href="$relpath$../../css/ost.css"
- type="text/css" media="screen"
- title="no title" charset="utf-8">
-</head>
-<body>
- <div id="content-holder">
- <div id="toc-box">
- <div id="menu">
- <a class="toc-title" >Site Navigation</a>
- <div class="toc-sep">
- <ul>
- <li><a href="$relpath$../../index.html">Home</a></li>
- <li><a href="$relpath$../../docs/tut/intro.html">Getting Started</a></li>
- <li><a href="$relpath$../../features.html">Features</a></li>
- <li><a href="$relpath$../../download.html">Download</a></li>
- <li><a href="$relpath$../../gallery.html">Gallery</a></li>
- <li><a href="$relpath$../../docs/index.html">Documentation</a></li>
- <ul>
- <li><a href="$relpath$../../docs/tutorials.html">Tutorials</a></li>
- <li><a href="$relpath$../../docs/examples.html">Examples</a></li>
- <li><a href="$relpath$../../dox/html/classes.html">Class List</a></li>
- </ul>
- <li><a href="$relpath$../../FAQ.html">Frequently Answered Questions</a></li>
-
- <li>
- <a href="$relpath$../../ack.html">Acknowledgements</a>
- </li>
- <li>
- <a href="$relpath$../../contact.html">Contact</a>
- </li>
- </ul>
- </div>
- <a class="toc-title" >API Documentation</a>
- <div class="toc-sep" >
- <ul>
- <li><a href="$relpath$functions.html">Function List</a></li>
- <li><a href="$relpath$classes.html">Class List</a></li>
- <li><a href="$relpath$files.html">File List</a></li>
- </ul>
- </div> <!--toc-sep-->
- </div><!--menu-->
- </div><!--toc-box-->
- <div id="content" >
diff --git a/website/mdx_toc2.py b/website/mdx_toc2.py
deleted file mode 100644
index e729eba58e42a695e1dbf32323896d6338a7b46e..0000000000000000000000000000000000000000
--- a/website/mdx_toc2.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Table of Contents Extension for Python-Markdown
-* * *
-
-(c) 2008 [Jack Miller](http://codezen.org)
-
-Dependencies:
-* [Markdown 2.0+](http://www.freewisdom.org/projects/python-markdown/)
-
-"""
-import markdown
-from markdown import etree
-import re
-
-class TocTreeprocessor(markdown.treeprocessors.Treeprocessor):
- # Iterator wrapper to get parent and child all at once
- def iterparent(self, root):
- for parent in root.getiterator():
- for child in parent:
- yield parent, child
- def __init__(self, md):
- markdown.treeprocessors.Treeprocessor.__init__(self, md)
- self.md=md
- def run(self, doc):
- div = etree.Element("div")
- self.md.DOC=doc
- div.attrib["class"] = "toc"
- last_li = None
- self.md.TOC=div
- # Add title to the div
- if self.config["title"][0]:
- header = etree.SubElement(div, "span")
- header.attrib["class"] = "toctitle"
- header.text = self.config["title"][0]
-
- level = 0
- list_stack=[div]
- header_rgx = re.compile("[Hh][12]")
-
- # Get a list of id attributes
- used_ids = []
- for c in doc.getiterator():
- if "id" in c.attrib:
- used_ids.append(c.attrib["id"])
-
- for (p, c) in self.iterparent(doc):
- if not c.text:
- continue
-
- # To keep the output from screwing up the
- # validation by putting a <div> inside of a <p>
- # we actually replace the <p> in its entirety.
- # We do not allow the marker inside a header as that
- # would causes an enless loop of placing a new TOC
- # inside previously generated TOC.
-
- if c.text.find(self.config["marker"][0]) > -1 and not header_rgx.match(c.tag):
- for i in range(len(p)):
- if p[i] == c:
- p[i] = etree.Element('span')
- break
-
- if header_rgx.match(c.tag):
- tag_level = int(c.tag[-1])
-
- while tag_level < level:
- list_stack.pop()
- level -= 1
-
- if tag_level > level:
- newlist = etree.Element("ul")
- if last_li:
- last_li.append(newlist)
- else:
- list_stack[-1].append(newlist)
- list_stack.append(newlist)
- level += 1
-
- # Do not override pre-existing ids
- if not "id" in c.attrib:
- id = self.config["slugify"][0](c.text)
- if id in used_ids:
- ctr = 1
- while "%s_%d" % (id, ctr) in used_ids:
- ctr += 1
- id = "%s_%d" % (id, ctr)
- used_ids.append(id)
- c.attrib["id"] = id
- else:
- id = c.attrib["id"]
-
- # List item link, to be inserted into the toc div
- last_li = etree.Element("li")
- link = etree.SubElement(last_li, "a")
- link.text=c.text
- link.attrib["href"] = self.md.doc_url+'#' + id
- if int(self.config["anchorlink"][0]):
- anchor = etree.SubElement(c, "a")
- anchor.text = c.text
- anchor.attrib["href"] = "#" + id
- anchor.attrib["class"] = "toclink"
- c.text=""
-
- list_stack[-1].append(last_li)
-
-class Toc2Extension(markdown.Extension):
- def __init__(self, configs):
- self.config = { "marker" : ["[TOC]",
- "Text to find and replace with Table of Contents -"
- "Defaults to \"[TOC]\""],
- "slugify" : [self.slugify,
- "Function to generate anchors based on header text-"
- "Defaults to a built in slugify function."],
- "title" : [None,
- "Title to insert into TOC <div> - "
- "Defaults to None"],
- "anchorlink" : [0,
- "1 if header should be a self link"
- "Defaults to 0"]}
-
- for key, value in configs:
- self.setConfig(key, value)
-
- # This is exactly the same as Django's slugify
- def slugify(self, value):
- """ Slugify a string, to make it URL friendly. """
- import unicodedata
- value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
- value = unicode(re.sub('[^\w\s-]', '', value).strip().lower())
- return re.sub('[-\s]+','-',value)
-
- def extendMarkdown(self, md, md_globals):
- tocext = TocTreeprocessor(md)
- tocext.config = self.config
- md.treeprocessors.add("toc2", tocext, "_begin")
-
-def makeExtension(configs={}):
- return Toc2Extension(configs=configs)
diff --git a/website/raw/100212_BE_Score.png b/website/raw/100212_BE_Score.png
deleted file mode 100644
index a2f61b2daa5dce11c79f92e643d345f16c1ed8f1..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_BE_Score.png and /dev/null differ
diff --git a/website/raw/100212_BE_Score_Tn.png b/website/raw/100212_BE_Score_Tn.png
deleted file mode 100644
index b0b145d1dbf74bd5fd856ed127ab123211deacfd..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_BE_Score_Tn.png and /dev/null differ
diff --git a/website/raw/100212_Loops.png b/website/raw/100212_Loops.png
deleted file mode 100644
index 8fd0ef54c4a96ed7ed0e7ca5063a9ec5371d2830..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Loops.png and /dev/null differ
diff --git a/website/raw/100212_Loops_Tn.png b/website/raw/100212_Loops_Tn.png
deleted file mode 100644
index 6b282039d298d541a0ec1d31d36e6d4239e89b27..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Loops_Tn.png and /dev/null differ
diff --git a/website/raw/100212_Openstructure1.0a1_1622_Linux.png b/website/raw/100212_Openstructure1.0a1_1622_Linux.png
deleted file mode 100644
index 9fdd4dbc62af07ea244933bb71477f07dce0ebb5..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Openstructure1.0a1_1622_Linux.png and /dev/null differ
diff --git a/website/raw/100212_Openstructure1.0a1_1622_Linux_Tn.png b/website/raw/100212_Openstructure1.0a1_1622_Linux_Tn.png
deleted file mode 100644
index cb38122a3afaabff6c617a6da7e7a37de0e37110..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Openstructure1.0a1_1622_Linux_Tn.png and /dev/null differ
diff --git a/website/raw/100212_Openstructure1.0a1_1622_Mac.png b/website/raw/100212_Openstructure1.0a1_1622_Mac.png
deleted file mode 100644
index 5a5274ee1b5f2f322b2bd129fa603203f4b2b924..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Openstructure1.0a1_1622_Mac.png and /dev/null differ
diff --git a/website/raw/100212_Openstructure1.0a1_1622_Mac_Tn.png b/website/raw/100212_Openstructure1.0a1_1622_Mac_Tn.png
deleted file mode 100644
index cc2cdaa60853bf35f97ae2e78328a8e12a7ada16..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Openstructure1.0a1_1622_Mac_Tn.png and /dev/null differ
diff --git a/website/raw/100212_Openstructure1.0a1_1622_Win.png b/website/raw/100212_Openstructure1.0a1_1622_Win.png
deleted file mode 100644
index bbda3547ed7046a8c4d00f3987a46775c275ff91..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Openstructure1.0a1_1622_Win.png and /dev/null differ
diff --git a/website/raw/100212_Openstructure1.0a1_1622_Win_Tn.png b/website/raw/100212_Openstructure1.0a1_1622_Win_Tn.png
deleted file mode 100644
index c403d3982910b394e78d2ec3872e50724994788e..0000000000000000000000000000000000000000
Binary files a/website/raw/100212_Openstructure1.0a1_1622_Win_Tn.png and /dev/null differ
diff --git a/website/raw/100611_Screenshot_Linux.png b/website/raw/100611_Screenshot_Linux.png
deleted file mode 100644
index 2d2890301cb502df2a4c4c386aec44c106893509..0000000000000000000000000000000000000000
Binary files a/website/raw/100611_Screenshot_Linux.png and /dev/null differ
diff --git a/website/raw/100611_Screenshot_Linux_TN.png b/website/raw/100611_Screenshot_Linux_TN.png
deleted file mode 100644
index 681597d7cef3f48df74593ae74f96e6b3a03d31a..0000000000000000000000000000000000000000
Binary files a/website/raw/100611_Screenshot_Linux_TN.png and /dev/null differ
diff --git a/website/raw/100611_Screenshot_Windows.png b/website/raw/100611_Screenshot_Windows.png
deleted file mode 100644
index 4cdbec9efd135495327baf791d92d9d08f371279..0000000000000000000000000000000000000000
Binary files a/website/raw/100611_Screenshot_Windows.png and /dev/null differ
diff --git a/website/raw/100611_Screenshot_Windows_TN.png b/website/raw/100611_Screenshot_Windows_TN.png
deleted file mode 100644
index a10eddf68f540e0edca1e474168775029d16a37a..0000000000000000000000000000000000000000
Binary files a/website/raw/100611_Screenshot_Windows_TN.png and /dev/null differ
diff --git a/website/raw/FAQ.mkdown b/website/raw/FAQ.mkdown
deleted file mode 100644
index 18cdb1afaf32c3da6e0d2d1d5a0053224221cd03..0000000000000000000000000000000000000000
--- a/website/raw/FAQ.mkdown
+++ /dev/null
@@ -1,28 +0,0 @@
-title: FAQ - Frequently Answered Questions
-
-#FAQ - Frequently Answered Questions
-
-**Which licensing does Openstructure come with?**
-
-Openstructure is released under GNU-LGPL license
-
-**Why another molecular Viewer?**
-
-Openstructure is not aiming to be a Viewer, but more a molecular modelling platform, a toolkit. It features nice graphics, though!
-
-**How do I load all PDB files in a directory?**
-
-The python glob module can be used to match files in a certain directory against a glob pattern. Then use LoadPDB as you normally would.
-
- ::::python
- import glob
- pdbs=[]
- for pdb_file in glob.glob(os.path.join(dir_path, '*.pdb')):
- pdbs.append(io.LoadPDB(os.path.join(dir_path, pdb_file)))
-
-**How do I load a crappy PDB file?**
-
-The easiest way is to use the `fault_tolerant` option of LoadPDB. If you set the value to true, it will load the structure and just skip erroneus records:
-
- ::::python
- ent=io.LoadPDB('pdb_with_errors.pdb', fault_tolerant=True)
\ No newline at end of file
diff --git a/website/raw/ack.mkdown b/website/raw/ack.mkdown
deleted file mode 100644
index 8a33b4bbdab8d985ccd66fa9ff3f4c79d9d19669..0000000000000000000000000000000000000000
--- a/website/raw/ack.mkdown
+++ /dev/null
@@ -1,32 +0,0 @@
-title: Acknowledgements
-
-# Acknowledgements
-
-Several people have been involved in the development and design of OpenStructure.
-
-## Core Development Team
-
-In alphabetical order:
-
- * *Marco Biasini [1]*
- * *Juergen Haas [1,2]*
- * *Valerio Mariani [1,2]*
- * *Ansgar Philippsen*
- * *Andreas Schenk [3]*
- * *Stefan Scheuber [1,2]*
-
-## Testing
-
- * *Tobias Schmidt [1,2]*
- * *Pascal Benkert [1,2]*
-
-
- [1] Swiss Institute of Bioinformatics, Basel, Switzerland
- [2] Biozentrum University of Basel, Basel, Switzerland
- [3] Department of Cell Biology, Harvard Medical School, Boston, MA, USA
-
-
-## Financial Support
-
-<a target="extern" href="http://www.isb-sib.ch/"><img alt="Swiss Institute of Bioinformatics" src="http://www.isb-sib.ch/images/stories/SIBlogo/sib_logoq_low.jpg" width="200" height="120"> </img></a>
-<a target="extern" href="http://www.biozentrum.unibas.ch"><img alt="Biozentrum" src="http://www.biozentrum.unibas.ch/logos101007/bio115_257.gif"> </img></a>
diff --git a/website/raw/contact.mkdown b/website/raw/contact.mkdown
deleted file mode 100644
index 9a67822ef330e46a7441d593b91ab9a1b6c01530..0000000000000000000000000000000000000000
--- a/website/raw/contact.mkdown
+++ /dev/null
@@ -1,16 +0,0 @@
-title: Contact
-
-# Contact
-
-## Community
-
-For general user inquiries and support: [openstructure-users mailing list](https://www.maillist.unibas.ch/mailman/listinfo/openstructure-users)
-
-Where the developers of OpenStructure discuss new features: [openstructure-devel mailing list](https://www.maillist.unibas.ch/mailman/listinfo/openstructure-devel)
-
-## Address
-Prof. Torsten Schwede
-SIB Swiss Institute of Bioinformatics
-Biozentrum University of Basel
-Klingelbergstrasse 50/70
-CH-4056 Basel / Switzerland
\ No newline at end of file
diff --git a/website/raw/css/ost.css b/website/raw/css/ost.css
deleted file mode 100644
index 1edb988f482e033c0dc953c16acaf190b89abe72..0000000000000000000000000000000000000000
--- a/website/raw/css/ost.css
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- alternatives: 005F6A, B84433
- */
-p, h1, h2, h3, ul, li, a, div{
- font-family:Verdana, sans-serif;
- font-size:10pt;
-}
-
-body {
- width:100%;
- height:100%;
-}
-
-img {
- border-style:none;
- margin-left:1em;
-}
-
-#content-holder {
- margin-top:1cm;
- margin-left:1cm;
- width:28cm;
- padding-left:0.2cm;
- background-color:white;
- border-color:#aaa;
- margin-bottom:0.2cm;
- padding-bottom:0.1cm;
-}
-#content {
- border-color:#dddddd;
- border-left-style:solid;
- border-width:1px;
- padding-left:10px;
- float:right;
- width:20cm;
- min-height:20cm;
-}
-code {
- font-family:Inconsolata, Menlo, Consolas, monospace;
- border-color:#eeeeee;
- border-width:1px;
- margin:0px;
- background-color:#fafafa;
-}
-
-a[href] {
- color:#B84433;
-}
-
-h1 {
- font-size:200%;
- font-weight:normal;
- color:#B84433;
- background: url('../logo.png') no-repeat;
- padding-left:48px;
- min-height:40px;
- margin-bottom:10px;
-
-}
-
-h3 {
- margin-bottom:0.2em;
-}
-
-h2 {
- font-family:Georgia, serif;
- padding-top:10pt;
- font-size:150%;
- color:#333333;
- font-weight:normal;
- font-style:italic;
-}
-p {
- padding:0cm;
- margin-top:0cm;
- margin-bottom:1em;
-}
-.groupHeader, h3 {
- margin-top:10pt;
- font-weight:bold;
-}
-
-#menu {
- /*text-align:right;*/
- padding-top:10px;
- float:left;
- width:7cm;
- /*background: #fff url('../loops.png') no-repeat +150px +26px;*/
-}
-#menu a {
- font-style:normal;
-}
-#menu li {
- list-style-type:none;
- padding:2px;
- margin:0px;
-}
-#menu ul {
- padding-left:10px;
- padding-bottom:5px;
-}
-table {
- padding:0px;
- margin:0px;
- width:70%;
-}
-
-.toc {
-}
-.toc ul {
- padding-left:20px;
- /*padding-bottom:5px;*/
-}
-.toc li {
- padding-top:5px;
- list-style-type:none;
-}
-
-#toc-box {
- position:fixed;
- top:27px;
-}
-.contents {
- padding:0px; margin:0px; border-width:0px;
-}
-pre.fragment {
- vertical-align:top;
- font-family:Inconsolata, Menlo, Consolas, monospace;
- border-color:#eee;
- padding-right:2px;
- margin:0px;
- padding:0.5em;
- border-width:1px;
- border-left-width:10px;
- border-left-color:#A5ABB9;
- border-style:solid;
- display:block;
-}
-
-.fragment a {
- font-family:Inconsolata, Menlo, Consolas, monospace;
-}
-
-
-.fragment .span {
- font-family:Inconsolata, Menlo, Consolas, monospace;
-}
-
-h2 a {
- font-size:100%;
- font-family:Georgia;
-}
-
-h1 a {
- font-size:100%;
-}
-
-.toc-sep {
- border-top: 1px solid #DDD;
- border-bottom: 1px solid #DDD;
-}
-.linenos {
- vertical-align:top;
- font-family:Inconsolata, Menlo, Consolas, monospace;
- background-color:#dddddd;
- color:#333333;
- width:20px;
- text-align:right;
- padding-right:2px;
- margin:0px;
- border-width:0px;
-}
-
-
-#footer {
- font-size:8pt;
- color:#333;
- border-color:#dddddd;
- border-width:1px;
- border-top-style:solid;
- vertical-align:bottom;
-}
-
-
-.fragment .comment {
- color: #8f5902; font-style: italic;
-}
-
-.fragment .keyword {
- color: #204a87; font-weight: bold;
-}
-
-.fragment .keywordflow {
- color: #204a87; font-weight: bold;
-}
-
-.fragment .stringliteral {
- color: #4e9a06;
-}
-
-
-.navpath {
- border-bottom-style:solid;
- border-bottom-color:#ddd;
- border-bottom-width:1px;
-}
-.navpath .el {
- text-decoration:none;
- font-style:normal;
-}
-
-.el, .memItemLeft, .memItemRight, .memname, .paramtype, .paramname {
- font-family:Inconsolata, Menlo, Consolas, monospace;
-}
-
-.memproto {
- border-top-style:solid;
- border-bottom-style:solid;
- border-top-width:1px;
- border-color:#ddd;
- border-bottom-width:1px;
- background-color:#eee;
- margin-top:20px;
-}
-
-div.codehilite {
- margin-left:0px;
- padding-left: 2em ;
- padding-right: 2em ;
- margin-bottom:1em;
- background-color: #fdfdfd;
- border-color:#eee;
- border-width:1px;
- border-style:solid;
- font-family:Inconsolata, Menlo, Consolas, monospace;
-}
-
-
-.codehilite .hll { background-color: #ffffcc }
-.codehilite .c { color: #8f5902; font-style: italic } /* Comment */
-.codehilite .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
-.codehilite .g { color: #000000 } /* Generic */
-.codehilite .k { color: #204a87; font-weight: bold } /* Keyword */
-.codehilite .l { color: #000000 } /* Literal */
-.codehilite .n { color: #000000 } /* Name */
-.codehilite .o { color: #ce5c00; font-weight: bold } /* Operator */
-.codehilite .x { color: #000000 } /* Other */
-.codehilite .p { color: #000000; font-weight: bold } /* Punctuation */
-.codehilite .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
-.codehilite .cp { color: #8f5902; font-style: italic } /* Comment.Preproc */
-.codehilite .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
-.codehilite .cs { color: #8f5902; font-style: italic } /* Comment.Special */
-.codehilite .gd { color: #a40000 } /* Generic.Deleted */
-.codehilite .ge { color: #000000; font-style: italic } /* Generic.Emph */
-.codehilite .gr { color: #ef2929 } /* Generic.Error */
-.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.codehilite .gi { color: #00A000 } /* Generic.Inserted */
-.codehilite .go { color: #000000; font-style: italic } /* Generic.Output */
-.codehilite .gp { color: #8f5902 } /* Generic.Prompt */
-.codehilite .gs { color: #000000; font-weight: bold } /* Generic.Strong */
-.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.codehilite .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
-.codehilite .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
-.codehilite .kd { color: #204a87; font-weight: bold } /* Keyword.Declaration */
-.codehilite .kn { color: #204a87; font-weight: bold } /* Keyword.Namespace */
-.codehilite .kp { color: #204a87; font-weight: bold } /* Keyword.Pseudo */
-.codehilite .kr { color: #204a87; font-weight: bold } /* Keyword.Reserved */
-.codehilite .kt { color: #204a87; font-weight: bold } /* Keyword.Type */
-.codehilite .ld { color: #000000 } /* Literal.Date */
-.codehilite .m { color: #0000cf; font-weight: bold } /* Literal.Number */
-.codehilite .s { color: #4e9a06 } /* Literal.String */
-.codehilite .na { color: #c4a000 } /* Name.Attribute */
-.codehilite .nb { color: #204a87 } /* Name.Builtin */
-.codehilite .nc { color: #000000 } /* Name.Class */
-.codehilite .no { color: #000000 } /* Name.Constant */
-.codehilite .nd { color: #5c35cc; font-weight: bold } /* Name.Decorator */
-.codehilite .ni { color: #ce5c00 } /* Name.Entity */
-.codehilite .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
-.codehilite .nf { color: #000000 } /* Name.Function */
-.codehilite .nl { color: #f57900 } /* Name.Label */
-.codehilite .nn { color: #000000 } /* Name.Namespace */
-.codehilite .nx { color: #000000 } /* Name.Other */
-.codehilite .py { color: #000000 } /* Name.Property */
-.codehilite .nt { color: #204a87; font-weight: bold } /* Name.Tag */
-.codehilite .nv { color: #000000 } /* Name.Variable */
-.codehilite .ow { color: #204a87; font-weight: bold } /* Operator.Word */
-.codehilite .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
-.codehilite .mf { color: #0000cf; font-weight: bold } /* Literal.Number.Float */
-.codehilite .mh { color: #0000cf; font-weight: bold } /* Literal.Number.Hex */
-.codehilite .mi { color: #0000cf; font-weight: bold } /* Literal.Number.Integer */
-.codehilite .mo { color: #0000cf; font-weight: bold } /* Literal.Number.Oct */
-.codehilite .sb { color: #4e9a06 } /* Literal.String.Backtick */
-.codehilite .sc { color: #4e9a06 } /* Literal.String.Char */
-.codehilite .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
-.codehilite .s2 { color: #4e9a06 } /* Literal.String.Double */
-.codehilite .se { color: #4e9a06 } /* Literal.String.Escape */
-.codehilite .sh { color: #4e9a06 } /* Literal.String.Heredoc */
-.codehilite .si { color: #4e9a06 } /* Literal.String.Interpol */
-.codehilite .sx { color: #4e9a06 } /* Literal.String.Other */
-.codehilite .sr { color: #4e9a06 } /* Literal.String.Regex */
-.codehilite .s1 { color: #4e9a06 } /* Literal.String.Single */
-.codehilite .ss { color: #4e9a06 } /* Literal.String.Symbol */
-.codehilite .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
-.codehilite .vc { color: #000000 } /* Name.Variable.Class */
-.codehilite .vg { color: #000000 } /* Name.Variable.Global */
-.codehilite .vi { color: #000000 } /* Name.Variable.Instance */
-.codehilite .il { color: #0000cf; font-weight: bold } /* Literal.Number.Integer.Long */
diff --git a/website/raw/docs/compile.mkdown b/website/raw/docs/compile.mkdown
deleted file mode 100644
index 56fe8da3b9d7d7524e065f67eb1f17120bd568f4..0000000000000000000000000000000000000000
--- a/website/raw/docs/compile.mkdown
+++ /dev/null
@@ -1,90 +0,0 @@
-title: Compiling and Building
-
-[TOC]
-
-# Compiling and Building OpenStructure
-
-## Installing the Dependencies
-
-OpenStructure uses a bunch of OpenSource libraries. If you haven't already installed them, please install them now!
-
- * [CMake][cmake]
- * [Eigen2](http://eigen.tuxfamily.org/)
- * [Boost](http://boost.org)
- * [libpng](http://www.libpng.org/)
- * [Python](http://python.org)
- * [Qt](http://qt.nokia.com/)
-
-When you enable support for image processing, you will need:
-
- * [FFTW3](http://fftw.org). By default, OpenStructure is compiled with single precision and thus also requires FFTW to be compiled with single precision. Most platforms offer this as a second package. If you are compiling manually, use the `--enable-single` option.
-
- * [libtiff](http://www.libtiff.org)
-
-
-
-If you would like to use the graphical user interface, also install:
-
- * [SIP](http://www.riverbankcomputing.co.uk/software/sip/download)
- * [PyQt4](http://www.riverbankcomputing.co.uk/software/pyqt/download)
-
-In case you are compiling under Windows you have to install [Visualstudio
-2008](http://www.microsoft.com/express/Downloads/) to compile the dependecies and
-OpenStructure. We recommend to compile the dependecies manually.
-Enter the directories where the dependencies are located in Tools->Options->Projects and Solutions->VC++
-directories. Choose 'bin' directories to enter program paths to cmake, qmake and python,
-'lib' directories to point to the location(s) of your dependencies.
-
-## Checking out the Source
-
-You can checkout the source from SVN. The repository is located at
-
- https://ost.biozentrum.unibas.ch/svn/openstructure/trunk
-
-If you are using the commandline client, type in your shell
-
- svn co https://ost.biozentrum.unibas.ch/svn/openstructure/trunk
-
-On Windows install svn clients like [tortoisesvn](http://tortoisesvn.tigris.org/) and use the function 'checkout' then enter the above mention URL.
-
-
-## Configuring
-
-OpenStructure uses [CMake][cmake] for compiling and building the project. The next required step is to configure the build environment using cmake. You can do that by invoking `cmake` in the project directory (On Windows choose Tools->visualstudio commandline prompt from within visualstudio) :
-
- cmake . <options>
-
-There are two kinds of options: Options that let you control the building behaviour, enabling and disabling the compilation of certain modules and options that let you tell CMake where to find the dependencies. All of them are passed to CMake with via `-D<opt>=<value>`.
-
-### Flag to choose build system
-
-On Windows make sure you specify -G"Visual Studio 9 2008"!
-
-### Flags that control the dependencies
-
-By default, [CMake] searches the standard directories for dependencies. However, on some systems, this might not be enough. Here is a short description of how CMake figures out what dependencies to take and how you can influence it.
-
- * Boost is mainly controlled via the `BOOST_ROOT` option. If boost wasn't found, it should be set to the prefix of the boost installation.
-
- * `QT_QMAKE_EXECUTABLE` defines the exact Qt installation to take. It should be set to the full path to ``qmake`.
-
- * `PYTHON_ROOT` is the Python equivalent of BOOST_ROOT. It should be set to the prefix path containing the python binary, headers and libraries.
-
- * `SYS_ROOT` controls the general prefix for searching libraries and headers. By default, it is set to `/`.
-
-### Flags that control the build
-
- * `ENABLE_UI` controls whether to build the graphical user interface module. By default it is set to true.
- * `ENABLE_IMG` controls whether to build the image processing module. This will enable support for density maps, and general image processing in 1, 2 an 3 dimensions. By default it is set to true.
- * `ENABLE_GFX` controls whether to build the graphics module. By default, this is set to true. If set to none, this implies `ENABLE_UI=NO`.
- * Shader support is controlled with `USE_SHADER`. By default, no shaders are used.
- * If `OPTIMIZE` is set to 1, an optimized version of OpenStructure is built.
-
-## Building the project
-
-Type `make`. If you are using a multi-core machine, you can use the `-j` flag to run
-multiple jobs at once.
-
-On Windows run 'Build OpenStructure' from the build menu.
-
-[CMake]: http://cmake.org
diff --git a/website/raw/docs/examples.mkdown b/website/raw/docs/examples.mkdown
deleted file mode 100644
index 71e660b483342780242fff07b40db231d8947f91..0000000000000000000000000000000000000000
--- a/website/raw/docs/examples.mkdown
+++ /dev/null
@@ -1,34 +0,0 @@
-title: Examples
-[TOC]
-# Examples
-
-Below you find a list of examples that should illustrate various aspects of interaction with OpenStructure itself and proteins in particular. Feel free to browse the [alphabetical examples list](dox/html/examples.html).
-
-## Examples by Topic
-
-### Graphics
- * ex[load_and_display.py|Loading And Displaying an Entity]
- * ex[rendermodes.py|Render Modes]
- * ex[primitives.py|Adding Lines and Quads] | ex[random_lines.py|Random Lines]
- * ex[bbox.py|Displaying a Bounding Box]
- * ex[gfx_symmetry.py|Drawing Symmetry Equivalents]
- * ex[gradient.py|Gradients]
- * ex[gfx_selection.py|Graphical Selection]
- * ex[color_by_property.py|Color Entity By Property]
-
-### GUI
- * ex[menubar_example.py|Adding a Menu]
- * ex[color_tool.py|Write a Tool in Python]
- * ex[widget_example.py|Add a custom Widget]
- * ex[mdi_example.py|Add a Widget to MDI]
-
-### Molecular Entities
- * ex[roll_helix.py|Modifying Protein Backbone Torsion Angles]
- * ex[bbox.py|Calculating an Oriented Bounding Box]
-
-### Image Processing
- * ex[create_split_image.py|Creating a Split Image from Several Images]
- * ex[fft_li.py|Load Images and Show Fourier Transforms]
- * ex[modulate_image.py|Load and Modulate Image by a Sine]
- * ex[spoke_pattern.py|Create a Spoke Pattern Image]
- * ex[view_phase_diff.py|Display Phase Difference of Two Images]
\ No newline at end of file
diff --git a/website/raw/docs/index.mkdown b/website/raw/docs/index.mkdown
deleted file mode 100644
index d678a7c3ad6cd3cb4212404caaae90453bccb975..0000000000000000000000000000000000000000
--- a/website/raw/docs/index.mkdown
+++ /dev/null
@@ -1,39 +0,0 @@
-title: Documentation
-[TOC]
-# Documentation
-
-## New to OpenStructure?
-
-Newcomers might want to have a look at our gentle [introduction to the framework](docs/tut/intro.html) and the [features list](features.html).
-
-For a conceptual overview of the framework, we have prepared a few [tutorials](docs/tutorials.html). You can also find [code examples](docs/examples.html) with a short description.
-
-
-## For Those Who Know
-
-The following links provide direct access to the API documentation.
-
-### Molecular Structures
- * dox[ost::mol::EntityHandle|EntityHandle] | dox[ost::mol::EntityView|EntityView] | [Queries](dox/html/query.html) | [Conop](dox/html/module_conop.html)
-
-### Sequence
-
- * [Overview](dox/html/module_seq.html)
-
-### Reading and writing files
-
- * [io](dox/html/module_io.html)
-
-### Graphics
-
- * dox[ost::gfx::Scene|Scene] | [Graphical Entity](dox/html/gfx_ent.html)
-
-### Image Manipulation
-
-
- * dox[ost::img::ImageHandle|ImageHandle]
-
-### Global Data Structure Index
- * [Data Structure index](dox/html/classes.html)
-
-
diff --git a/website/raw/docs/tut/100208_Inspector_Gadget.png b/website/raw/docs/tut/100208_Inspector_Gadget.png
deleted file mode 100644
index 9d5d9e45f481a071df9f328aea5103483c5c25cf..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100208_Inspector_Gadget.png and /dev/null differ
diff --git a/website/raw/docs/tut/100208_OpenStructure_UI_Colored.png b/website/raw/docs/tut/100208_OpenStructure_UI_Colored.png
deleted file mode 100644
index 53338891b594d8dc23e2b9ea509a30c01b5dcb45..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100208_OpenStructure_UI_Colored.png and /dev/null differ
diff --git a/website/raw/docs/tut/100208_Scene_Win.png b/website/raw/docs/tut/100208_Scene_Win.png
deleted file mode 100644
index 6a473dd9edac11351e5de2a06e615ecc46f8585c..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100208_Scene_Win.png and /dev/null differ
diff --git a/website/raw/docs/tut/100208_Tools.png b/website/raw/docs/tut/100208_Tools.png
deleted file mode 100644
index 7d6a4c87d28975b575b25201e6e6b8f758eebf75..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100208_Tools.png and /dev/null differ
diff --git a/website/raw/docs/tut/100210_auto_completion.png b/website/raw/docs/tut/100210_auto_completion.png
deleted file mode 100644
index ba3f14437cb98d612c6a1b7f07e080f595a0397a..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100210_auto_completion.png and /dev/null differ
diff --git a/website/raw/docs/tut/100210_multi_line.png b/website/raw/docs/tut/100210_multi_line.png
deleted file mode 100644
index 8a37894d787737e0d7278edd29273518f22c5f39..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100210_multi_line.png and /dev/null differ
diff --git a/website/raw/docs/tut/100210_path_completion.png b/website/raw/docs/tut/100210_path_completion.png
deleted file mode 100644
index fa1e1d820417382addaa75b23d2a41996058b005..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100210_path_completion.png and /dev/null differ
diff --git a/website/raw/docs/tut/100210_single_line.png b/website/raw/docs/tut/100210_single_line.png
deleted file mode 100644
index de79f55106aceb62d5d8a33af7f539415b317d76..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/100210_single_line.png and /dev/null differ
diff --git a/website/raw/docs/tut/dv1.jpg b/website/raw/docs/tut/dv1.jpg
deleted file mode 100644
index a6fbfb26ff61b5be6b618cb2231c63dab436e557..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/dv1.jpg and /dev/null differ
diff --git a/website/raw/docs/tut/dv2.jpg b/website/raw/docs/tut/dv2.jpg
deleted file mode 100644
index 14d8b5d9aa83baa14cd749262e074afeae189442..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/dv2.jpg and /dev/null differ
diff --git a/website/raw/docs/tut/dv3.jpg b/website/raw/docs/tut/dv3.jpg
deleted file mode 100644
index 4cd45aea3d439c5a7eff2a0e4f763a93d1ea2cbc..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/dv3.jpg and /dev/null differ
diff --git a/website/raw/docs/tut/external.mkdown b/website/raw/docs/tut/external.mkdown
deleted file mode 100644
index 022e504859e4c7cef0fbdcd0ed49a3471a3b658e..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/external.mkdown
+++ /dev/null
@@ -1,96 +0,0 @@
-title: Using External Programs within OpenStructure
-
-[TOC]
-
-# Using External Programs within OpenStructure
-
-## Introduction
-It is often very useful to use external programs to do a specific task. In principle, this can be done by writing out files from OpenStructure and manually running an external program, however, for convenience, this can also be done directly from within OpenStructure using Python commands.
-
-This tutorial will give you some hints how to do this for a new external program. The process basically consists of four steps:
-
- * locate the executable of the external program
- * prepare all necessary files
- * execute the external program from python
- * read in generated output
-
-All existing bindings to external programs are placed under ost::bindings.
-
-## Locating the Executable
-There is a helper function available to locate files. It can be found at ost::settings::Locate(). Using this, you can obtain the full path of an executable.
-
-As an example, we would like to obtain the full path of the msms executable (a program to calculate molecular surfaces):
-
- ::::python
- from ost import settings
- exe_path=settings.Locate('msms', search_paths=['/opt/app','/home/app'],
- env_name='MSMS', search_system_paths=True)
- print exe_path
-
-The Locate command looks for the program with the name 'msms'. If env_name is set, it first looks if an environment variable with the name 'MSMS' is set. If not, all paths in search_paths are searched. If the executable could still not be found and search_system_paths is set to True, the binary search paths are searched.
-If the executable could not be found, a FileNotFound exception is raised with a detailed description where Locate was searching for the executable.
-
-## Prepare All Files
-The preparation of the necessary files is very dependent on the external program. Often it is useful to generate a temporary directory or file. For this, the python module tempfile is very handy.
-
-An example how to generate a temporary directory, open a file in this directory and write the position and radius of all atoms into this file is shown here:
-
- ::::python
- import tempfile
- import os
-
- # generate a temporary directory
- tmp_dir_name=tempfile.mkdtemp()
- print 'temporary directory:',tmp_dir_name
-
- # generate and open a file in the temp directory
- tmp_file_name=os.path.join(tmp_dir_name,"entity")
- tmp_file_handle=open(tmp_file_name, 'w')
- print 'temporary file:',tmp_file_handle
-
- # write position and radius of all atoms to file
- for a in entity.GetAtomList():
- position=a.GetPos()
- tmp_file_handle.write('%8.3f %8.3f %8.3f %4.2f\n' % (position[0],
- position[1], position[2], a.GetProp().radius))
-
- # close the file
- tmp_file_handle.close()
-
-## Execute the External Program
-The external program can be executed from python using the python module subprocess.
-
-To run the external program msms from the above example, with the temporary file generated before, we can use the following:
-
- ::::python
- import subprocess
-
- # set the command to execute
- command="%s -if %s -of %s" % (exe_path,
- tmp_file_name, tmp_file_name)
- print 'command:',command
-
- # run the executable with the command
- proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
- stdout_value, stderr_value = proc.communicate()
-
- #check for successful completion of msms
- if proc.returncode!=0:
- print "WARNING: msms error\n", stdout_value
- raise subprocess.CalledProcessError(proc.returncode, command)
-
- # print everything written to the command line (stdout)
- print stdout_value
-
-## Read Generated Output
-The last step includes reading of generated files (like in the case of msms) and/or processing of the generated command line output.
-
-Here we first print the command line output and then load the generated msms surface and print the number of vertex points:
-
- ::::python
- # print everything written to the command line (stdout)
- print stdout_value
-
- # read msms surface from file
- surface=io.LoadSurface(tmp_file_name, "msms")
- print 'number of vertices:',len(surface.GetVertexIDList())
diff --git a/website/raw/docs/tut/genericprop.mkdown b/website/raw/docs/tut/genericprop.mkdown
deleted file mode 100644
index 5e57f18dd067fb7991eb60ebab20f2edfbeaeca4..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/genericprop.mkdown
+++ /dev/null
@@ -1,71 +0,0 @@
-title: Storing Custom Data in an Entity
-
-[TOC]
-
-# Storing Custom Data in an Entity
-This tutorial will guide you through the use of GenericProperties to store any custom data inside an Entity.
-
-## Introduction
-It is often very convenient to store any arbitrary data inside an Entity. A few examples are:
-
- * calculated properties of atoms
- * sequence conservation of a residue
- * interaction energy of a substructure with its surrounding
- * fit of a fragment inside an electron density map
-
-In OpenStructure this is supported by the use of GenericProperties. Most building blocks are a dox[ost::GenericPropertyContainer|GenericPropertyContainer], meaning that arbitrary key-value pairs can be stored in them, namely:
-
- * EntityHandle and EntityView
- * ChainHandle and ChainView
- * ResidueHandle and ResidueView
- * AtomHandle and AtomView
- * BondHandle
-
-The view variants will reflect the generic properties of the handle variants.
-
-A generic property key is always a String, and a value can be one of String, Real, int or bool. For each of these data types, methods to retrieve and store values are available both in Python and C++.
-
-## Storing and Accessing Data
-
-All OpenStructure building blocks that are GenericPropertyContainers, have four different methods to store generic data, depending on the data type (i.e. String, Float, Int or Bool).
-
-To store a float value with the key 'myfloatprop' in all atoms of an entity:
-
- ::::python
- import math
- for atom in entity.GetAtomList():
- val=5*math.sin(0.4*atom.GetPos().GetX())
- atom.SetFloatProp("myfloatprop", val)
-
-If a GenericProperty at a given level (i.e. atom, bond, residue, chain or entity) already exists, it will be overwritten. To check if it exists, use:
-
- ::::python
- exists=atom.HasProp("myfloatprop")
- print exists
-
-To access the value of a GenericProperty, we first check if the property exists and then access it, using the method suitable for the data type of the property. For the previously set property "myfloatprop" of the data type Real, at the atom level:
-
- ::::python
- for atom in entity.GetAtomList():
- if atom.HasProp("myfloatprop"):
- print atom.GetFloatProp("myfloatprop")
-
-When trying to access a property that has not been set, or one that has been set, but at a different level, an error is thrown. The same is true when trying to access a property of a different data type, e.g.:
-
- ::::python
- # all of the following lines will throw errors
- # error because the property does not exist
- print atom.GetFloatProp("unknownprop")
-
- # error because the property was set at another level
- print entity.GetFloatProp("myfloatprop")
-
- # error because the data type of the property is different
- print atom.GetStringProp("myfloatprop")
-
-For more details see dox[ost::GenericPropertyContainer|GenericPropertyContainer].
-
-## Use of GenericProperties in Queries
-
-The [query language](docs/tut/query.html) can also be used for numeric generic properties (i.e. FloatProp and IntProp), but the syntax is slightly different. To access any generic properties, it needs to be specified that they are generic and at which level they are defined. Therefore, all generic properties start with a 'g', followed by an 'a', 'r' or 'c' for atom, residue or chain level respectively. For more details [see documentation](dox/html/query.html#gen_prop).
-
diff --git a/website/raw/docs/tut/gui.mkdown b/website/raw/docs/tut/gui.mkdown
deleted file mode 100644
index b2ead57d0c97b7f257c3dcd39f2f9e8cc29b6536..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/gui.mkdown
+++ /dev/null
@@ -1,64 +0,0 @@
-title: Graphical User Interface
-
-[TOC]
-
-# Graphical User Interface
-
-The GUI of OpenStructure is designed to be intuitive, flexible and extensible. Most of the widgets are organized in a big main window which is divided into four parts: the main area and three panels containing one or more smaller widgets:
-
-
-
-The panels primarily contains widgets interacting with the 3D window.
-All parts of the GUI are exported to Python and can be expanded with C++ Qt widgets as well as with PyQt widgets.
-
-## SceneWin
-The scene win holds a list of all graphical objects currently registered to the dox[ost::gfx::Scene|scene].
-
-
-
-Every node of the graphical scene tree is shown as a subnode of the scene. It is possible to select one or more objects in the scenewin (ctrl+ left mouse click). The available actions of the context menu are applied to all currently selected objects.
-
-## Inspector Gadget
-With our Inspector Gadget it is straightforward to modify rendering and coloring options of scene objects without using the keyboard:
-
-
-
-The render and coloring options affect only the currently selected objects of the scene win. The Shortcut "Ctrl+I" toggles the visibility of the inspector.
-
-## Tools
-OpenStructure has several dox[ost::gui::Tool|tools] which are all listed in the toolbar close to the 3D window. A tool is activated upon selecting it in the toolbar. Input events are sent to the tool as long as the `Ctrl` key (`Cmd` on Mac) is pressed. For example the rigid body manipulator will rotate and shift the currently selected nodes in the scene win. Upon releasing `Ctrl`, the events are sent to the camera, making it possible to rapidly switch between adjusting the viewing angle of the camera and manipulating the position and orientation of scene objects.
-
-
-
-The example ex[color_tool.py|Write a Tool in Python] demonstrates how to add a simple tool (written in python) to OpenStructure.
-
-## Drag and Drop support
-The user interface of OpenStructure supports drag and drop events. Every file format that is supported by Openstructure can be opened by dragging and dropping it on the main window. When a python script (ending with .py) is being dropped on the UI, the script will be executed. For any other file type (for example PDB files, images and density maps), OpenStructure will try to load the file and either display in the 3D window or in the data viewer for images.
-
-## Python Shell
-OpenStructure has a integrated python shell which allows you interactively enter Python commands. Learn more about it in the [Python Shell tutorial](docs/tut/pythonshell.html).
-
-## The Side Panels
-
-### View Modes
-Each dox[ost::gui::PanelBar|side panel] can have different dox[ost::gui::PanelWidgetContainer|view modes]. View modes can display the widgets which are held by the Side Panel in a different style. Every panel has the splitter and the tabbed view mode. The view mode can be changed in the Window menu of the Menubar.
-
-### Drag and Drop
-The widgets which are held by a Side Panel can be moved to an other position in the panel or even to another side panel. The widget can be moved by simply clicking on the border of the widget and drag and drop it to the desired position. The drag and drop feature is currently only supported by the splitter view mode.
-
-### Adding a custom Widget
-The Left-, Bottom- and Right-Panel are organized by one dox[ost::gui::Panels|Superclass]. It is only possible to display a widget which is in the dox[ost::gui::WidgetPool|widget pool] of the panels class. Once a widget is in the pool all the methods of the Panels class can be used to display / hide the widget in any position of the panels.
-The Example ex[widget_example.py|Add a custom Widget] describes, how to add a fancy PyQt Widget to the widget pool and finally display it in the right side bar.
-OpenStructure remembers the size and location of a Widget. So, OpenStructure should look the same after restarting it.
-
-## Main Area
-
-### Adding an own Widget
-The dox[ost::gui::MainArea|main area] is a mdi (multi document interface). Therefore it's possible to display multiple widgets in it. The example ex[mdi_example.py|Add a Widget to MDI] demonstrates how to add a widget to the MDI area.
-
-## Menubar
-### Adding an new Menupoint
-It is really straightforward to add a custom menupoint. Since the menubar is exported to Python it is even easier to create such e menupoint. See the example ex[menubar_example.py|Adding a Menu] which describes how this is done within python and PyQt.
-
-## Nice to know
-As you might have noticed nearly every gui example needs the dox[ost::gui::GostyApp|gosty app] and the dox[ost::gui::Perspective|perspective] within the code. Gosty app is a singleton class which has getter methods to all important gui classes. The perspective class has all the information about the layout of the whole application, it is accessible over the gosty app instance.
diff --git a/website/raw/docs/tut/imgalg.mkdown b/website/raw/docs/tut/imgalg.mkdown
deleted file mode 100644
index 8b2d4eeebece5c2f4805b2b2ea0abdc59ae034c8..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgalg.mkdown
+++ /dev/null
@@ -1,62 +0,0 @@
-title: Algorithms for Images and Density Maps
-
-[TOC]
-
-# Algorithms for Images and Density Maps
-
-
-## The Basics
-
-To allow various image manipulation routines that are decoupled from the actual
-image implementations, an extensive set of algorithm base classes is provided to facilitate
-the implementation of novel algorithms.
-
-The 'img' module is using the concept of algorithm objects: In order to apply an algorithm
-to an image, an instance of that particular algorithm class must be created, which
-is then passed to one of the various Apply methods of the dox[ost::img::ImageHandle|ImageHandle]
-interface. This extends the possibilities of algorithms beyond what is possible with simple
-function calls.
-
-## Algorithm Types
-
-Five different types of algorithms can be identified:
-
-### NonMod
-An algorithm that will not modify the values in the image, but rather gather
-some data. Example: a histogram. Implemented as dox[ost::img::NonModAlgorithm|NonModAlgorithm].
-
-### ModIP
-An algorithm that will modify the image values directly in place; in addition,
-it may choose to write to its internal state during application of the algorithm.
-Implemented as dox[ost::img::ModIPAlgorithm|ModIPAlgorithm].
-
-### ConstModIP
-Similar to ModIP, this algorithm will modify the values directly in place.
-However, it does not need to store information itself beyond the application of the algorithm
-itself. Example: setting all image values to zero. Implemented as
-dox[ost::img::ConstModIPAlgorithm|ConstModIPAlgorithm].
-
-### ModOP
-An algorithm that will return a new, modified version of the image, while
-leaving the original untouched. Again, the algorithm can store information to be available
-after it has been applied. Implemented as dox[ost::img::ModOPAlgorithm|ModOPAlgorithm].
-
-### ConstModOP
-Similar to ModOP, except that no information can be stored beyond the
-application of the algorithm itself. Example: rotation around an arbitrary angle. Implemented
-as dox[ost::img::ConstModOPAlgorithm|ConstModOPAlgorithm].
-
-## Implemented algorithms
-
-A list of implemented algorithms can be found [here](docs/tut/imgalglist.html)
-
-## Custom Algorithms (for developers)
-
-Writing custom algorithms for the 'img' module is fairly straightforward, in view of the fact that the final
-algorithm will integrate seamlessly into the build environment, both at the C++ and Python runtime
-levels. Information on how to write custom algorithms can be found at the
-[Algorithm Tutorial page](docs/tut/imgalgdata.html).
-
-There are two fundamental types of algorithms, those that operate on high level
-ImageHandle instances, [Data Algorithms](docs/tut/imgalgdata.html), and those that
-operate on the low level ImageState instances, [ImageState Algorithms](docs/tut/imgalgdistate.html).
diff --git a/website/raw/docs/tut/imgalgdata.mkdown b/website/raw/docs/tut/imgalgdata.mkdown
deleted file mode 100644
index 23b0bb130eb97169f375b7c7a0ba8bd6038cdeec..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgalgdata.mkdown
+++ /dev/null
@@ -1,466 +0,0 @@
-title: Data Algorithms - An Algorithm Tutorial
-
-[TOC]
-
-# Data Algorithms - An Algorithm Tutorial
-
-This tutorial shows how to create custom high level dox[ost::img::ImageHandle|ImageHandle] algorithms and
-embed them into the OpenStructure build system. As an example, two very simple algorithm will be written:
-The first will count all values in an image or function that are larger than a certain threshold. Since this
-algorithm only needs to read values, it will be implemented by deriving it from ConstAlgorithm. The second algorithm
-will set all values below a certain threshold to the threshold value; this will be implemented
-using ModIPAlgorithm.
-
-Naming is important. We need a name for the collection (or module) of algorithms, as well as
-a name for each individual one within the collection. For this example, the module name is
-'thres', the first algorithm will be called 'ThresCount', and the second one 'ThresSet'.
-
-The new module will be built following the guidelines on [this page](docs/tut/newmodule.html).
-The information on the linked page will not be repeated here, so it advisable to read it before
-continuing with this tutorial
-
-In the end, this algorithm module will consist of:
-
-* Two header files, which are staged under 'stage/include/ost/thres' to allow other
-components (such as the unit-tests, the python module, or other algorithms) to utilize
-the module.
-* A shared library called 'libost_thres', which is staged in 'stage/lib' and
-required at run-time.
-* A shared Python object named '_thres.so', which is staged under
-'stage/lib/ost/pymod/ost/thres'.
-* A Python initialization file '\_\_init\_\_.py', which is also staged under
-'/lib/ost/pymod/ost/thres' and is required for the directory 'thres' to be recognized as a
- Python module.
-
-
-## Algorithm Test Setup
-
-Surprising or irritating as it may seem, the first thing on the agenda is the unit
-test for this algorithm, located under 'thres/tests';.
-
-Note
-: Tests, and in this particular case unit-test, are an essential component of any
-modern software development effort. They not only ascertain the continued correct
-functionality after refactoring cycles or platform porting, they often consist
-in the first step of writing new code: First you write the test, then you
-implement the functionality. Sounds crazy? Really works! You can call that
-developing in expectancy mode.
-
-### Preparing the Testing Framework
-
-The main testing code is put into 'tests.cc', there is nothing particular to discuss here:
-
- :::cpp
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- #include "test_thres_count.hh"
- #include "test_thres_set.hh"
-
- test_suite*
- unit_unit_test_suite( int argc, char * argv[] ) {
- std::auto_ptr<test_suite> test(BOOST_TEST_SUITE( "Module thres Test" ));
-
- test->add(CreateThresCountTest());
- test->add(CreateThresSetTest());
-
- return test.release();
- }
-
-
-The factory function declaration for the counting algorithm is put into 'test\_thres\_count.hh':
-
- :::cpp
- #ifndef OST_THRES_TEST_COUNT_H
- #define OST_THRES_TEST_COUNT_H
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- test_suite* CreateThresCountTest();
-
- #endif
-
-And the one for the threshold setting algorithm is put into 'test\_thres\_set.hh':
-
- :::cpp
- #ifndef OST_THRES_TEST_SET_H
- #define OST_THRES_TEST_SET_H
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- test_suite* CreateThresSetTest();
-
- #endif
-
-
-## Writitng the UnitTests
-
-Now lets fill in the actual algorithm usage code. First, the declaration of the
-algorithm needs to be included from its header. These are the two 'include'
-statements we want to add, along with the 'namespace' code:
-
- :::cpp
- #include <ost/img/image.hh>
- #include <ost/thres/thres_count.hh>
-
- using namespace ost::img;
- using namespace ost::thres;
-
-
-The first 'include' line and the 'ost::img' 'namespace' directive are needed
-for creating and handling an ImageHandle. They use elements which are part of
-the standard OpensStructure distribution. The others lines are required for our
-particular algorithm class.
-
-Note
-: Neither the file 'thres\_count.hh' exists yet nor the namespace 'thres'.
-Remember, this is coding in expectency mode, ie we expect the algorithm to be
-used in this way.
-
-Next, the testing routine. As a first thing, an image needs
-to be created, with which the functionality of the algorithm can be tested:
-
- :::cpp
- ImageHandle ih = CreateImage(Extent((Size(4,4))));
-
-The factory method CreateImage() from the standard OpenStructure
-distribution takes care of this. The dox[ost::img::ImageHandle|ImageHandle]
-'ih' now referes to a 4x4 real, spatial image, with all values set to zero. To
-populate the image with values, the following code is used:
-
- :::cpp
- double v=0.0;
- for(ExtentIterator(ih.GetExtent()); !it.AtEnd(); ++it) {
- ih.SetReal(it, v);
- v+=1.0;
- }
-
-Now the algorithm object of our ThresCount class is created.
-
- ThresCount thres_count(5.0);
-
-Note
-: Again, this is in expectancy mode: We want to have an algorithm that uses a
-threshold, and it makes only sense that this threshold is given upon instantiation;
-we will need to remember this once we implement the constructor.
-As the next step, the algorithm is applied to the image, using the appropriate
-method from dox[ost::img::ImageHandle|ImageHandle]:
-
- :::cpp
- ih.Apply(a);
-
-Finally the test: since the values in the image were consecutively set from 0.0
-to 15.0, what is the expected outcome of the algorithm? In the above description,
-it says "counts all values larger than a given threshold". In this case particular
-test case this means all values above 5.0, so the expected count is 10.
-
-To retrieve the count, the algorithm object requires some sort of getter method,
-which we expect to be called 'GetCount()'. This is combined with the 'boost::test'
-facility macro to see if the algorithm worked:
-
- :::cpp
- BOOST_CHECK(a.GetCount()==10);
-
-That's it.
-
-Here is the finished file 'test\_thres\_count.cc'.
-
- :::cpp
- #include "test_thres_count.hh"
-
- #include <ost/img/image.hh>
- #include <ost/thres_count.hh>
- using namespace ost::img;
- using namespace ost::thres;
-
- namespace test_thres_count {
-
- void test()
- {
- ImageHandle ih = CreateImage(Extent((Size(4,4))));
-
- double v=0.0;
- for(ExtentIterator it(ih.GetExtent()); !it.AtEnd(); ++it) {
- ih.SetReal(it, v);
- v+=1.0;
- }
- ThresCount thres_count(5.0);
-
- ih.Apply(thres_count);
-
- BOOST_CHECK(thres_count.GetCount()==10);
- }
-
- }
-
- test_suite* CreateThresCountTest()
- {
- using namespace test_thres_count;
- test_suite* ts=BOOST_TEST_SUITE("ThresCount Test");
-
- ts->add(BOOST_TEST_CASE(&test));
-
- return ts;
- }
-
-The test for 'ThresSet' algorithm is build in a similar way. A test image is setup, and the
-initialization of the algorithm should also accept the threshold value to be used:
-
- :::cpp
- ImageHandle ih = CreateImage(Extent((Size(4,4))));
-
- double v=0.0;
- for(ExtentIterator it(ih.GetExtent()); !it.AtEnd(); ++it) {
- ih.SetReal(it, v);
- v+=1.0;
- }
-
- ThresCount thres_set(5.0);
-
- ih.ApplyIP(thres_set);
-
-Note
-: There are two posibilities to apply this algorithm to the image: in-place
-(used here) and out-of-place. This works even though the ThresSet algorithm itself
-is implemented in-place. What is the expected outcome of applying the algorithm?
-The description above said: "will set all values below a certain threshold to
-the threshold value". Therefore there should not be a value below 5.0 in the image:
-
- :::cpp
- for(ExtentIterator it(ih.GetExtent()); !it.AtEnd(); ++it) {
- BOOST_CHECK(ih.GetReal(it)>=5.0);
- }
-
-Here is the final test file 'test\_thres\_set'.cc:
-
- :::cpp
- #include "test_thres_set.hh"
-
- #include <ost/img/image.hh>
- #include <ost/thres/thres_set.hh>
- using namespace ost::img;
- using namespace ost::thres;
-
- namespace test_thres_set {
-
- void test()
- {
- ImageHandle ih = CreateImage(Extent((Size(4,4))));
-
- double v=0.0;
- for(ExtentIterator it(ih.GetExtent()); !it.AtEnd(); ++it) {
- ih.SetReal(it, v);
- v+=1.0;
- }
-
- ThresSet thres_set(5.0);
-
- ih.ApplyIP(thres_set);
-
- for(ExtentIterator it(ih.GetExtent()); !it.AtEnd(); ++it) {
- BOOST_CHECK(ih.GetReal(it)>=5.0);
- }
- }
- }
-
- test_suite* CreateThresSetTest()
- {
- using namespace test_thres_set;
- test_suite* ts=BOOST_TEST_SUITE("ThresSet Test");
-
- ts->add(BOOST_TEST_CASE(&test));
-
- return ts;
- }
-
-Obviously, all files need to be added to the 'CMakeLists.txt' file in 'thres/tests.'
-Also, all the module dependencies must be added. In our example the dependencies are
-the 'ost\_img' and 'ost\_img\_alg' module, plus the 'ost\_thres' moudle itself.
-
-## Coding Algorithm
-
-After so much expecting and looking into the future, this is the part where the
-actual algorithm gets implemented. The CMake building script will also be setup to place the
-headers and library files at the right location, so thay they are found by the unit tests.
-
-In the 'thes/src' directory, let's add the header and source files for the two algorithms.
-
-Here is 'thres\_count.hh:
-
- :::cpp
- #ifndef OST_TRES_THRES_COUNT_H
- #define OST_TRES_THRES_COUNT_H
-
- #include <ost/img/algorithm.hh>
-
- namespace ost { namespace thres {
-
- class ThresCount: public NonModAlgorithm
- {
- public:
- ThresCount(Real thres);
-
- // retrieve count
- int GetCount() const;
-
- // algorithm interface
- virtual void Visit(const ConstImageHandle& i);
- virtual void Visit(const Function& f);
-
- protected:
- void VisitData(const Data& d);
-
- private:
- Real thres_;
- int count_;
- };
-
- }} // namespaces
-
- #endif
-
-And here is 'thres\_count.cc':
-
- :::cpp
- #include "thres_count.hh"
-
- using namespace ost::img;
- using namespace ost::thres;
-
- ThresCount::ThresCount(Real thres):
- NonModAlgorithm("ThresCount"),
- thres_(thres),
- count_(0)
- {}
-
- void ThresCount::Visit(const ConstImageHandle& i)
- {
- // reroute to generic method
- VisitData(i);
- }
-
- void ThresCount::Visit(const Function& f)
- {
- // reroute to generic method
- VisitData(f);
- }
-
- void ThresCount::VisitData(const Data& d)
- {
- count_=0; // make sure count is reset for each visit
- for(ExtentIterator it(d.GetExtent()); !it.AtEnd(); ++it) {
- if(d.GetReal(it)>thres_) {
- ++count_;
- }
- }
- }
-
- int ThresCount::GetCount() const
- {
- return count_;
- }
-
-Note
-: The polymorphic separation into 'dox[ost::img::ConstImageHandle|ConstImageHandle]' and
-'Function' is not utilized in this example, since both 'Visit()' methods just call
-'VisitData()' to perform the actual calculation. The method body of 'VisitData()'
-is the actual algorithm implementation, using the private member variables 'thres\_'
-and 'count\_'.
-
-Here is the 'thres\_set.hh' file:
-
- :::cpp
- #ifndef OST_THRES_THRES_SET_H
- #define OST_THRES_THRES_SET_H
-
- #include <ost/img/algorithm.hh>
-
- namespace ost { namespace thres {
-
- class ThresSet: public ModIPAlgorithm
- {
- public:
- ThresSet(Real thres);
-
- // algorithm interface
- virtual void Visit(ImageHandle& i);
-
- private:
- Real thres_;
- };
-
- }} // namespaces
-
- #endif
-
-
-And here is 'thres_set.cc':
-
- :::cpp
- #include "thres_set.hh"
-
- using namespace ost::img;
- using namespace ost::thres;
-
- ThresSet::ThresSet(Real thres):
- ModIPAlgorithm("ThresSet"),
- thres_(thres)
- {}
-
- void ThresSet::Visit(ImageHandle& i)
- {
- for(ExtentIterator it(i.GetExtent()); !it.AtEnd(); ++it) {
- if(i.GetReal(it)<thres_) {
- i.SetReal(it,thres_);
- }
- }
- }
-
-Once again, all the files must be added to the 'CMakeLists.txt' file, this time in
-'thres/src'. This will make sure that all the headers and the newly created shared libraries
-are staged correctly. The 'DEPENDS ON' directive in the file should include the 'img'
-and 'img_alg' modules, since those are the modules 'thres' depends on.
-
-## Python Wrapper
-
-Finally, let's export both both 'ThresCount' and 'ThresSet' to Python, as part of
-the 'thres' module. Let's put the following 'wrap\_thres.cc' file in the 'src/pymod' directory
-
- :::cpp
- #include <boost/python.hpp>
- using namespace boost::python;
-
- #include <ost/thres/thres_count.hh>
- #include <ost/thres/thres_set.hh>
-
- using namespace ost::img;
- using namespace ost::thres;
-
- BOOST_PYTHON_MODULE(_tres)
- {
- class_<ThresCount, bases<NonModAlgorithm> >("ThresCount", init<Real>() )
- .def("GetCount", &ThresCount::GetCount)
- ;
-
- class_<ThresSet, bases<ModIPAlgorithm> >("ThresSet", init<Real>() )
- ;
- }
-
-After adding the 'wrap_thres.cc' file to the 'CMakeLists.txt' file in 'thres/pymod, let's also put the
-following '\_\_init.py\_\_' file in the same directory:
-
- :::python
- from _thres import *
-
-The next time that the OpenStructure project will be compiled, the headers, the shared libraries and
-the python modules from the new 'thres' module wil be staged and the two new Image algorithms will be made available
-in both Python and C++.
-
-
-
-
-
-
-
diff --git a/website/raw/docs/tut/imgalgdistate.mkdown b/website/raw/docs/tut/imgalgdistate.mkdown
deleted file mode 100644
index 1b544b8c3ac001c6f98c50a931f0e6e83bf882c9..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgalgdistate.mkdown
+++ /dev/null
@@ -1,51 +0,0 @@
-title: Image State Algorithms
-
-[TOC]
-
-# Image State Algorithms
-
-## Overview
-
-In order to allow fast access to the low level image state implementation, the
-data algorithms are complemented by a similar concept, namely image state algorithms.
-
-Analogous to the image state implementation, each of the different image state
-algorithms is composed of a double template combination, specifying the data type
-(real or complex) and the domain (spatial, frequency or half-frequency). And
-analogous to the data algorithm, there are different algorithms dependent on the
-purpose of the algorithm to be implemented: non-modifying, in-place modifying and
--of-place modifying.
-
-In should be pointed out the the image state algorithms are really a hybrid
-concept, as they may be used as normal data algorithms as well !
-
-A class with a specific structure is required that is later used as a template
-parameter. The exact syntax is dependent on the type of algorithm. The minimal
-interface comprises two methods: a ding VisitState(), and a (possibly static)
-GetAlgorithmName(). Additional methods may be added, in particular a destruct or
-and/or special constructors.
-
-## Example of ImageState algorithm
-
-This is an example of a NonMod algorithm
-
- :::pp
- class MyAlgorithmFnc
- {
- public:
- MyAlgorithmFunc();
-
- // other ctors
-
- // entry point for image state visitor
- template<typename T, class D>
- void VisitState(const img::image_state::ImageStateImpl<T,D>& isi);
-
- // entry point for function visitor
- void VisitFunction(const Funcion& f);
-
- // name of algorithm
- static string GetAlgorithmName();
-
- // other methods may follow here
- };
diff --git a/website/raw/docs/tut/imgalglist.mkdown b/website/raw/docs/tut/imgalglist.mkdown
deleted file mode 100644
index 6d52a91969f32fb077ecdfb5caf1308b0c3ba538..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgalglist.mkdown
+++ /dev/null
@@ -1,82 +0,0 @@
-title: List of image algorithms
-
-[TOC]
-
-# List of image algorithms
-
-## General Algorithms
-
-* dox[ost::img::alg::Clear|Clear]
-* dox[ost::img::alg::Fill|Fill]
-* dox[ost::img::alg::Stat|Stat]
-* dox[ost::img::alg::StatMinMax|StatMinMax]
-* dox[ost::img::alg::Negate|Negate]
-* dox[ost::img::alg::Polar|Polar]
-* dox[ost::img::alg::Randomize|Randomize]
-* dox[ost::img::alg::AutoCorrelate|AutoCorrelate]
-* dox[ost::img::alg::Conjugate|Conjugate]
-* dox[ost::img::alg::Convolute|Convolute]
-* dox[ost::img::alg::Correlate|Correlate]
-* dox[ost::img::alg::CrossCorrelate|CrossCorrelate]
-* dox[ost::img::alg::HighestPeakSearch3D|HighestPeakSearch3D]
-* dox[ost::img::alg::Histogram|Histogram]
-* dox[ost::img::alg::RsCrosscorr|RsCrosscorr]
-* dox[ost::img::alg::LineAverage|LineAverage]
-* dox[ost::img::alg::LineIterator|LineIterator]
-
-## Fourier Transforms
-
-* dox[ost::img::alg::FFT|FFT]
-* dox[ost::img::alg::DFT|DFT]
-* dox[ost::img::alg::PowerSpectrum|PowerSpectrum]
-
-
-## Transformations
-
-* dox[ost::img::alg::Mirror|Mirror]
-* dox[ost::img::alg::Shift|Shift]
-* dox[ost::img::alg::Transform|Transform]
-* dox[ost::img::alg::FractionalShift|FractionalShift]
-* dox[ost::img::alg::DiscreteShrink|DiscreteShrink]
-
-
-## Masking
-
-* dox[ost::img::alg::MaskImage|MaskImage]
-* dox[ost::img::alg::SmoothMaskImage|SmoothMaskImage]
-
-
-## Normalizer
-
-* dox[ost::img::alg::LinearNormalizer|LinearNormalizer]
-* dox[ost::img::alg::LogNormalizer|LogNormalizer]
-* dox[ost::img::alg::ODNormalizer|ODNormalizer]
-
-
-## Thresholding
-
-* dox[ost::img::alg::ClipMinMax|ClipMinMax]
-* dox[ost::img::alg::DensitySlice|DensitySlice]
-* dox[ost::img::alg::Threshold|Threshold]
-* dox[ost::img::alg::LocalSigmaThreshold|LocalSigmaThreshold]
-
-
-## General filters
-
-* dox[ost::img::alg::Anisotropic|Anisotropic]
-* dox[ost::img::alg::Gaussian|Gaussian]
-* dox[ost::img::alg::GaussianGradientMagnitude|GaussianGradientMagnitude]
-* dox[ost::img::alg::GaussianLaplacian|GaussianLaplacian]
-
-
-## High/low pass filters
-
-* dox[ost::img::alg::LowPassFilter|LowPassFilter]
-* dox[ost::img::alg::HighPassFilter|HighPassFilter]
-* dox[ost::img::alg::GaussianLowPassFilter|GaussianLowPassFilter]
-* dox[ost::img::alg::GaussianHighPassFilter|GaussianHighPassFilter]
-* dox[ost::img::alg::FermiLowPassFilter|FermiLowPassFilter]
-* dox[ost::img::alg::FermiHighPassFilter|FermiHighPassFilter]
-* dox[ost::img::alg::ButterworthLowPassFilter|ButterworthLowPassFilter]
-* dox[ost::img::alg::ButterworthHighPassFilter|ButterworthHighPassFilter]
-
diff --git a/website/raw/docs/tut/imgdataviewer.mkdown b/website/raw/docs/tut/imgdataviewer.mkdown
deleted file mode 100644
index bbf902d9f7cccb1bcb6d96f9c073e748afe67e3d..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgdataviewer.mkdown
+++ /dev/null
@@ -1,120 +0,0 @@
-title: Data Viewer
-
-[TOC]
-
-#Data Viewer
-
-## Introduction
-
-The Data Viewer can display a single real or reciprocal space image with adjustable
-contrast. Phases in reciprocal space images can be visualized using the phase color mode.
-The data viewer can be created and also be controlled via the Python/C++ interface.
-Extension of the data viewer is possible using additional [overlays](docs/tut/imgoverlays.html).
-
-The DataViewer shows several panels. In each several actions can be performed using
-the keyboard and mouse interface, as described below. A status bar is also present in
-the DataViewer, displaying the zoom level of the image shown in the main panel, and showing
-the coordinates of the last clicked pixel.
-
-## Components
-
-## Main panel
-
-The main panel shows the image either in Real space or Fourier space. The phase
-color display mode can be activated using the pop up menu.
-
-|Mouse Event | Action |
-|:---------------|-------------------------------:|
-|Left Button | Draw Selection Box |
-|Middle Button | Move Selection |
-|Right Button | Move Image, Display Popup Menu |
-|Wheel | Zoom In And Out |
-
-|Key | Action |
-|:---------------|-------------------------------:|
-|N | Renormalize |
-|C | Center |
-|I | Invert |
-|P | Toggle Phasecolor Mode |
-|V | Show / Hide Pixel Values |
-|S | Toggle Selection Mode |
-|R | Show / Hide Ruler |
-|+,L | Zoom In |
-|-,K | Zoom Out |
-|Z | Previous Slab |
-|X | Next Slab |
-|SHIFT + Mouse | Update Zoom and Live FFT Panel |
-|CTRL + Mouse | Interact with Overlay |
-
-## Zoom panel
-
-The zoom panel shows a zoomed version of the image centered at the mouse position.
-
-|Mouse Event | Action |
-|:---------------|-------------------------------:|
-|Left Button | Draw Selection Box |
-|Middle Button | Move Selection |
-|Right Button | Move Image, Display Popup Menu |
-|Wheel | Zoom In And Out |
-
-|Key | Action |
-|:---------------|-------------------------------:|
-|N | Renormalize |
-|I | Invert |
-|P | Toggle Phasecolor Mode |
-|V | Show / Hide Pixel Values |
-|S | Toggle Selection Mode |
-|+,L | Zoom In |
-|-,K | Zoom Out |
-
-## Live FFT panel
-
-The live FFT panel show a live FFT of the area centered at the current mouse
-position. The size of the Fourier transformed area can be adjusted using the
-popup menu.
-
-|Mouse Event | Action |
-|:---------------|-------------------------------:|
-|Left Button | Draw Selection Box |
-|Middle Button | Move Selection |
-|Right Button | Move Image, Display Popup Menu |
-|Wheel | Zoom In And Out |
-
-|Key | Action |
-|:---------------|-------------------------------:|
-|N | Renormalize |
-|C | Center |
-|I | Invert |
-|P | Toggle Phasecolor Mode |
-|V | Show / Hide Pixel Values |
-|S | Toggle Selection Mode |
-|+,L | Zoom In |
-|-,K | Zoom Out |
-
-## Argand panel
-
-The argand panel shows an argand diagram of the selected pixels.
-
-## Info panel
-
-The Info panel shows the x an y coordinates and the value of the last clicked
-pixel and the pixel at the current mouse position. In addition the extent of
-the selection box is displayed.
-
-|Mouse Event | Action |
-|:---------------|-------------------------------:|
-|Right Button | Display Popup Menu |
-
-## Python/C++ interface
-
-The data viewer can be created and also be controlled via a Python/C++ interface.
-Following python code loads an image and creates a new viewer for it.
-
- ::::python
- im=io.LoadImage("...")
- v=gui.CreateDataViewer(im)
-
-The viewer instance v provides following methods. See the dox[ost::img::gui::DataViewer|DataViewer]
-class documentation.
-
-
diff --git a/website/raw/docs/tut/imgintro.mkdown b/website/raw/docs/tut/imgintro.mkdown
deleted file mode 100644
index 0c177c565ce87cbc41a7858a0177f1d127239f32..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgintro.mkdown
+++ /dev/null
@@ -1,172 +0,0 @@
-title: Images / Density Maps - An Introduction
-
-[TOC]
-
-# Images / Density Maps - An Introduction
-
-## Introduction : The ImageHandle
-
-OpenStructure offers extensive processing capabilities for planar 2d images and
-3d maps using the img module. Images are manipulated through the use of
-dox[ost::img::ImageHandle|ImageHandles].
-
-ImageHandles provide a clean and efficient interface to interact
-with images and maps. An ImageHandle can store an image in either real
-('SPATIAL') or Fourier ('FREQUENCY') space and always keep track of the currently active domain.
-This means,for example that one can apply a Fourier Transformation to an ImageHandle containing a
-'SPATIAL' image and the ImageHandle will correctly identify the new active domain as 'FREQUENCY'. The
-ImageHandle also understands, for example, that applying a Fourier Transform to a centrosymmetric
-'FREQUENCY' image results in a real 'SPATIAL' image, but applying it to a non-centrosymmetric one results
-in a complex 'SPATIAL' image.
-
-Furthermore, the ImageHandle will make sure that real and
-Fourier space information about the image are always in sync. If, for example, the pixel sampling is
-changed while the current active domain is real space,
-the pixel sampling in Fourier space will be adjusted accordingly, and vice versa.
-
-Moreover, the ImageHandle allows the extraction of both complex and real numeric values
-from images in any active domain. If the domain is complex in nature, but a real numeric value
-is requested, the amplitude of the complex number will be returned. If the numerical nature
-of the domain is real and a complex number is requested, the complex part will be set
-to 0.
-
-## Creating and visualizing ImageHandles
-
-As a first step, enter the following lines in the OpenStructure python console:
-
- :::python
- im=img.CreateImage(img.Size(200,200))
-
-
-This will create an empty, 2D image, with a height and width of 200 pixels, whose
-origin (ie the pixel with the coordinates <0,0>) is in the top-left corner.
-
- :::python
- v=gui.CreateDataViewer(im)
-
-A viewer window will pop up (see below), showing a white frame on a black background.
-The inner area of the white frame is the image, which is empty.
-
-## Reading and writing into an image
-
-Data can be read and written from and into an image using the following commands:
-
- ::python
- # writes the real value 23.4 into pixel 10,10
- im.SetReal(img.Point(10,10),23.4)
- # reads the value in pixel 10,10
- val=im.GetReal(img.Point(10,10))
-
-The complex equivalents are also available
-
- ::python
- # writes the complex value value 2+3j into pixel 10,10
- im.SetComplex(img.Point(10,10),2+3j)
- # reads the value in pixel 10,10
- val=im.GetComplex(img.Point(10,10))
-
-The image knows in which domain it is, and will adjust the type of data being written
-accordingly. For example, if one writes a complex value in a 'SPATIAL' image, the value
-will be automatically converted to a real one by taking the amplitude of the complex number
-On the other hand, if one writes a real value in a 'FREQUENCY' image, the value is automatically
-converted to complex by setting the imaginary part to 0.
-
-## Applying algorithms
-
-Let us fill the image with random values.
-
- :::python
- rand_alg = img.alg.Randomize() # create algorithm object
- im.ApplyIP( rand_alg ) # apply algorithm object in-place
-
-As you can see, applying an algorithm is conceptually a two-step process. First,
-an instance of an algorithm class is created, yielding an algorithm object (in this
-case 'rand\_alg'). In a second step, the algorithm object is applied to an image,
-either in-place, modifying the image, or out-of-place, leaving the original image
-untouched, and returning the result as a new image. Note that the in-place/out-of-place
-logic is decoupled from the algorithm object.
-
-Now that we have some (noisy) data present, let us run another algorithm, this time
-a Gaussian filter with a sigma of 4 pixel.
-
- :::python
- im.ApplyIP( img.alg.GaussianFilter(4.0) ) # apply temporary algorithm object in-place
-
-As you can see, it is not always necessary to create an independent algorithm instance first,
-in many cases a temporary object will suffice (this applies to the randomization
-algorithm as well, 'im.ApplyIP(alg.Randomize())' would have been fine). However,
-when used this way, the algorithm class will cease to exist as soon as the algorithm
-is applied. This can be important if the algorithm stores some values that need to be
-recovered later. For example:
-
- :::python
- stat=img.alg.Stat()
- im.ApplyIP(stat)
- mean=stat.GetMean()
-
-Algorithms are stateful objects and can store values. The 'Stat' algorithm computes
-basic statistics about the image it is applied on (maximum and minimum values, standard
-deviations, etc). The data are stored within the algorithm instance and can be recovered
-using the algorithm's methods. It would obviously make very little sense not to create an
-instance of the 'Stat' algorithm. When the algorithms ceases to exist, all
-information would be lost.
-
-## Applying a Fourier Transform
-
-An image is Fourier-transformed using the 'img.alg.FFT()' algorithm object:
-
- :::python
- im=io.LoadImage("imagename.tif") # load the image
- # create an instance of the fft algorithm object
- fft=img.alg.FFT()
- # do the actual Fourier transformation
- im_ft=im.Apply(fft)
- # back-transform
- im2 = im_ft.Apply(fft)
- # if this is run from within the dng graphical frontend, open viewers to look at the images
- gui.CreateDataViewer(im)
- gui.CreateDataViewer(im_ft)
- gui.CreateDataViewer(im2)
-
-It is not really necessary to use the 'fft' variable to store the 'im.alg.FFT()' instance, a temporary object can be used, since the 'FFT' algorithm object is stateless. In addition, the algorithm can be applied in-place to avoid the creation of a second image:
-
- :::python
- im=io.LoadImage("imagename.tif") # load the image
- # do the actual Fourier transformation, in-place using temporary object
- im.ApplyIP(alg.FFT())
- # repeating this command will do the back-transform
- im.ApplyIP(alg.FFT())
-
-As said before, the 'alg.FFT()' algorithm does not require a direction to be given, this is implicitly
-determined by the active domain of the underlying image state: a 'SPATIAL' image will always be
-transformed to the 'FREQUENCY' domain, and vice-versa.
-
-## Extracting and Pasting Images
-
-An image can be extracted and pasted into another image using the 'Extract()' and
-'Paste()' member functions:
-
- :::python
- # load the image
- im=io.LoadImage("imagename.tif")
- # generate a subimage from the region going from (10,10) to (30,30)
- im2=im.Extract(img.Extent(img.Point(10,10),img.Point(30,30)))
- # generate an empty image with the same size as the original image
- im3=img.CreateImage(im.GetExtent())
- # paste the subimage into the empty image
- im3.Paste(im2)
-
-Note that the extent is fully honored for the paste operation, i.e. only the
-region where the pasted-to and the pasted-in image overlap will be affected.
-
-
-
-
-| | | |
-|:-------------------------------------------------:|:-------------------------------------------------------------------:|:------------------------------------------------------------------------:|
-|![Empty Image] (docs/tut/dv1.jpg "Empty Image") | ![After Randomization] (docs/tut/dv2.jpg "After Randomization") | ![After Gaussian Filtering] (docs/tut/dv3.jpg "After Randomization") |
-|Empty Image | After Randomization | After Gaussian Filtering |
-
-
-
-
diff --git a/website/raw/docs/tut/imgoverlays.mkdown b/website/raw/docs/tut/imgoverlays.mkdown
deleted file mode 100644
index f84b883fb3c05a8183647c369ce1587e515f9bed..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/imgoverlays.mkdown
+++ /dev/null
@@ -1,59 +0,0 @@
-[TOC]
-
-# Overlays
-
-The DataViewer may be extended by an arbitrary amount overlays. These are
-classes derived from 'ost::img::gui::Overlay', either directly in Python or
-written in C++ and then exported to Python. They are added dynamically to each
-viewer by means of the DataViewer::AddOverlay method.
-
-An overlay can draw on top of an image in the OnDraw method. If it is the
-active Overlay, it also receives mouse and keyboard events via the OnMouseEvent
-and OnKeyEvent methods. A minimalistic overlay that demonstrates this functionality
-is given below, and can also be found in `modules/gui/src/data_viewer/null_overlay.hh'.
-
- :::cpp
- #include <ost/gui/data_viewer/overlay_base.hh>
-
- class NullOverlay: public ost::img::gui::Overlay
- {
- public:
- // the ctor must initialize the Overlay base class with a name
- NullOverlay():
- Overlay("NullOverlay")
- {}
-
- // This must be implemented to allow duplication
- virtual OverlayPtr Clone() const {
- return OverlayPtr(new NullOverlay(*this));
- }
-
- // This method is called for each redraw of the image viewer, after the image itself
- // has been rendered in the view widget. The device context as well as the data viewer
- // panel are passed
- virtual void OnDraw(wxDC& dc, const img::gui::DataViewerPanel* dvp, bool is_active)
- {
- }
-
- // Called if this is the active overlay, passing the mouse event. Must return flag to
- // indicate wether the event was handled (true), or not (false), where the latter allows
- // the image viewer to handle the event itself
- virtual bool OnMouseEvent(const wxMouseEvent& e)
- {
- return false;
- }
-
- // dito for a key event
- virtual bool OnKeyEvent(const wxKeyEvent& e)
- {
- return false;
- }
-
- // allows a custom overlay menu to be included, a return of 0 indicates no menu
- virtual wxMenu* GetMenu()
- {
- return 0;
- }
- }
-
-
\ No newline at end of file
diff --git a/website/raw/docs/tut/intro.mkdown b/website/raw/docs/tut/intro.mkdown
deleted file mode 100644
index 63a4d1c93b41f3bb862748755d31ca9505043fb0..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/intro.mkdown
+++ /dev/null
@@ -1,250 +0,0 @@
-title: Introduction to OpenStructure
-
-[TOC]
-
-# A gentle introduction to OpenStructure
-
-In this tutorial you will be learning by example how to use the OpenStructure framework.
-
-We assume that you already have a version of OpenStructure installed. If not, please refer to the [installation instructions](download.html).
-
-## What will be covered in this tutorial?
-
-This tutorial is aimed at users that would like to get their hands dirty and execute commands in Python and write scripts rather clicking their way through a shiny user interface. The user interface of OpenStructure is in a very early state anyway that you probably won't go far by clicking you way through...
-
-The first part of the tutorial is a walk-through of the basic functionality you will be using in your everyday work. You will learn how to load structure datasets, inspect, display them in the 3D window and save them.
-
-
-## Getting ready to rumble
-
-The files we will be using in the tutorial are available in the examples folder that comes with OpenStructure. Depending on your platform, the examples are located at a different location:
-
- * on *MacOS X* the files are in /Library/OpenStructure/examples or $HOME/Library/OpenStructure/examples, depending on whether you installed the framework for a single user or system-wide.
- * on *Linux* and *Windows* PREFIX/share/openstructure/examples, where PREFIX is the path to the directory containing OpenStructure.
-
-### Starting DNG
-
-The graphical user interface of OpenStructure is called DNG (Dino/DeepView Next Generation). To start it,
-
- * on *MacOS X* double click DNG.app in /Applications or $HOME/Applications
- * on *Windows* double click dng.bat inside the PREFIX/bin directory
- * on *Linux* fire up a terminal change into the OpenStructure installation directory and type 'bin/dng'. If you have the binary directory in the PATH, typing dng is sufficient.
-
-### Interactive Python Shell
-Now we will enter commands in the [python shell](docs/tut/pythonshell.html) (in the screenshot above, the python shell is located at the bottom of the main window). If you want to get more information on any object, function or class, the python help command may be useful. For example:
-
- ::::python
- # get list of methods of EntityView
- help(mol.EntityView)
- # get help for method Select
- help(mol.EntityView.Select)
-
-## Loading and inspecting a protein structure
-
-OpenStructure has a module that is dedicated to deal with input and output of data, including sequence alignment formats, protein structures and density data and images. If you are reading this tutorial you most certainly have dealt with protein structures before and you are most certainly aware that they are usually stored in Brookhaven structure files (aka PDB files). The official name for molecules stored in a PDB file is an entity. You will hear this word throughout this tutorial, but you can replace the word entity with molecule in your head.
-
-Before using the load functionality, you have to import the io module. This is done by typing the following command in the [python shell](docs/tut/pythonshell.html):
-
- ::::python
- from ost import io
-To load a PDB file, type
-
- ::::python
- fragment=io.LoadPDB('PATH_TO_EXAMPLES/entity/fragment.pdb')
-This will load the fragment from the specified file 'fragment.pdb' and store the result in fragment. For more information on the LoadPDB function, type
-
- ::::python
- help(io.LoadPDB)
-Now let's inspect what we just loaded:
-
- ::::python
- print fragment.chain_count
- print fragment.residue_count
- print fragment.atom_count
-
-As you can see, our fragment consists of one peptide chain of 12 amino acids and has 81 atoms in total. Now let's examine our fragment even further. Enter the command
-
- ::::python
- for residue in fragment.residues:
- print residue
-This will print a list of all residues in the fragment. Similarly to get a list of atoms, use:
-
- ::::python
- for atom in fragment.atoms:
- print atom
-
-Of course, we can also get a list of atoms grouped by residues:
-
- ::::python
- for residue in fragment.residues:
- print residue, 'has', residue.atom_count, 'atom(s).'
- for atom in residue.atoms:
- print ' ', atom.name, atom.pos
-
-And, for completeness, we will first group them by chain, then by residues.
-
- ::::python
- for chain in fragment.chains:
- print 'chain', chain.name, 'has', chain.residue_count, 'residue(s)'
- for residue in chain.residues:
- print ' ', residue, 'has', residue.atom_count, 'atom(s).'
- for atom in residue.atoms:
- print ' ', atom.name, atom.pos
-Aah, wait! A protein fragment would not be complete without bonds: Let's see what bonds we have in there:
-
- ::::python
- for bond in fragment.bonds:
- print bond
-From these short code examples we already see how the entity is structured: On one hand we have a hierarchy of chains, residues and atoms. On the other hand, we have bonds that form a network overlayed on the hierarchy. This is illustrated in the picture on the left. An important feature of entities is that we can always assume that the hierarchy is intact. You will never find an atom without residues, no residue can exist without a parent chain and chains belong always to an entity.
-
-## Let There Be Shiny Graphics
-
-For visually inspecting the fragment, we now create a graphical representation:
-
- ::::python
- go=gfx.Entity("Fragment", fragment)
- scene.Add(go)
- scene.CenterOn(go)
-
-Now you will see the fragment in the 3D window (left):
-
-
-
-Use the mouse to rotate, zoom in an shift the camera. Double clicking on an atom will center the camera on that atom.
-
-## Introduction to Views
-
-Often during processing and visualisation of data, only parts of a protein structure are of interest. This realisation has had a major impact on the design of OpenStructure and is tied very deeply into the core of the framework. Subparts of structure are modeled as so-called dox[ost::mol::EntityView|EntityViews]. You can think of them as a selection of chains, residues, atoms and bonds of an entity. A views has almost the same interface as the underlying entity, making it very easy to mix entity views with handles in Python due to the dynamic nature of the language. An algorithm that is written for entities will almost always (with some care) also work for dox[ost::mol::EntityHandle|EntityHandles]. This is referred to as [duck-typing](http://en.wikipedia.org/wiki/Duck_typing) (I don' t care if it is a duck as long as it looks like a duck), a concept used all over the place in Python.
-
-A typical view can be seen in the image on the left. The view consists of one chain, one residue and two atoms. Again the same rule applies: No atom can be part of the view without it's residue. In this example, no bonds are included, since there is at most one atom per bond in the original structure.
-
-To familiarize yourself with the concept of views, we will use the fragment in the 3D window.
-
-We will use several ways to select parts of our fragment:
-
- * By using a dedicated query language
- * By manually constructing a view
-
-## The Query Language
-
-The first way to select parts of a structure is with a dedicated mini-language, called ["the query language”](docs/tut/query.html). In the Python Shell, type
-
- ::::python
- go.selection=fragment.Select('')
-A green halo will be displayed around the selected parts (image in the middle).
-
- As you can see the previous statement created a “full view”, containing all the chains, residues, atoms and bonds. To select lysine residues, type
-
- ::::python
- go.selection=fragment.Select('rname=LYS')
-
-
-As you can see (image in the middle), the only lysine residue is now highlighted in the 3D window, because it was the only one matching the predicate “residue name must be equal to LYS”. Several such predicates can be combined with boolean operators such as “and” and “or”. To select residues with residue number 1 to 3, the following statement will do the job:
-
- ::::python
- go.selection=fragment.Select('rnum>=1 and rnum<=3')
-but this is very cumbersome. That's why there is a shortcut to this statement. You can specify a range of values.
-
- ::::python
- go.selection=fragment.Select('rnum=1:3')
-For a complete description of what you can do with the query language, have a look at the [query language introduction](docs/tut/query.html) or at the [reference page](dox/html/query.html).
-
-
-## Constructing Views Manually
-
-Sometimes the query language Is Not Enough (TM). For these cases the construction of manual entities becomes neccessary. This is pretty straight forward:
-
- ::::python
- view=fragment.CreateEmptyView()
- ca=fragment.FindAtom('A', mol.ResNum(1), 'CA')
- cb=fragment.FindAtom('A', mol.ResNum(1), 'CB')
- view.AddAtom(ca)
- view.AddAtom(cb)
- go.SetSelection(view)
-
-The last step sets our constructed view as the current selection, displaying it in the 3D window. As you can see, C-alpha and C-beta of the first residue are not connected by bonds, even though both atoms are in the view. You have either to add the bond manually with
-
- ::::python
- ca_cb=ca.FindBondToAtom(cb)
- view.AddBond(ca_cb)
-
-Or as a very convenient shortcut 'view.AddAllInclusiveBonds()' to add all bonds that have both bonding partners in the view.
-
-Don't forget to call update the selection of the graphics object to see what view you have created.
-
-## Saving an Entity
-
-Saving an entity (or a view) is a breeze:
-
-Type
-
- ::::python
- io.SavePDB(fragment, 'full.pdb')
-to save the full view. To save only the backbone atoms, we can first select the backbone atoms and then save it:
-
- ::::python
- io.SavePDB(fragment.Select('aname=CA,C,N,O'), 'backbone.pdb')
-
-
-## Loading images and density maps
-
-Openstructure features a img module that is dedicated to the manipulation of images / density maps. The images or density maps can either be one-, two- or three-dimensional. The most common formats used in x-ray and electron crystallography and atomic force microscope are supported in addition to several general purpose image formats. See (feature list)[feature_list.html] for details.
-The img module was originally developed as part of the Image Processing Library & Toolbox IPLT. More documentation and examples can also be found on the [IPLT website](http://www.iplt.org).
-
-Before using the load functionality for an image, you have to import the io module. This is done by typing the following command in the python shell:
-
- ::::python
- from ost import io
-
-To load a density map, type
-
- ::::python
- the_map=io.LoadImage('/path/to/examples/map/1ppt.map')
-
-This will load the fragment density map from the specified file '1ppt.map' and store the result in the_map.
-
-Now let's inspect what we just loaded:
-
- ::::python
- print the_map.GetPixelSampling()
-
-We can see that the sampling is set to 1.0 Angstroems in all three dimensions.
-
-## Manipulating images and density maps
-
-The algorithms used for manipulation of an image are found in the img.alg module. Therefore before using an algorithm we first have to import the img.alg module.
-
- ::::python
- from ost.img import alg
-
-
-The img.alg module provides a wide range of algorithm to manipulate image data. Here for the example we use a LowPassFilter to restrict the resolution of the density map.
-
- ::::python
- map_filtered=the_map.Apply(alg.LowPassFilter(3.0))
-
-The filtered map is stored in a new variable called fragment\_map\_filtered.
-
-
-## Displaying images and density maps
-
-Now that we have a filtered map it's time to have a look at it. There are fundamentally two ways to visualize 3-dimensional density maps.
-One is by drawing isosurfaces. These are conceputally similar to contour lines used in cartography: every point on an isosurface has the same
-density value. Isosurfaces are easy to create in OpenStructure:
-
- ::::python
- go=gfx.MapIso("filtered", map_filtered,0.5)
- scene.Add(go)
-
-The other way to visualize a 3-dimensional map is by showing one 2-dimensional density slice at a time, allowing
-the user to move through the slices. In OpenStructure this is achieved using a [DataViewer](docs/tut/imgdataviewer.html). A DataViewer showing the
-filtered map is created using the following command:
-
- ::::python
- gui.CreateDataViewer(map_filtered)
-
-This command displays a panel showing one slice of the density map lying on a particular (x,y) plane in the coordinate reference system.
-The 'z' and 'x' keys can be used to move to slices lying at a lower or higher coordinate along the 'z' axis, allowing the examination of
-the full 3-dimensional volume.
-
-Are more detailed explanation of the img module can be found in the tutorial section for [images and density maps](docs/tut/imgintro.html).
diff --git a/website/raw/docs/tut/newmodule.mkdown b/website/raw/docs/tut/newmodule.mkdown
deleted file mode 100644
index a8a200ba19991558639d1300ce6bd5342b48b6c1..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/newmodule.mkdown
+++ /dev/null
@@ -1,274 +0,0 @@
-title: Extending OpenStructure - Creating a New Module
-
-[TOC]
-
-# Extending OpenStructure - Creating a new module
-
-OpenStructure can be extended by writing additional modules. A module will consist of
-a set of C++ classes and methods, most of which will also be exported to Python.
-
-The build system of OpenStructure is quite simple. The main difference to other projects
-is the use of a so-called stage directory. The stage directory replicates the normal layout of
-a standard Linux directory structure, with an 'include' directory for the headers, a 'lib' directory
-containing the shared library files, a 'bin' directory for the executables and a 'share' directory for the
-platform-independent data like icons, images and examples.
-
-OpenStructure uses [CMake](http://www.cmake.org/) to build the project. The rules for the build-system
-are defined in 'CMakeLists.txt' files. When running CMake, the files are compiled and copied into stage. The
-real installation, if necessary, happens at a later stage. This is referred to as staging of the files.
-
-If a new module is written following the guidelines in this page, it will be
-seamlessly included in the build system and will then be available form both
-the DNG python console and the OpenStructure command line as any other native module.
-
-As a first step, a new directory structure must be created to accommodate the new module.
-
-## Directory structure
-
-For the purpose of this example, let's assume we are creating a new module called
-'mod' (for 'modeling'). Let's create a directory named 'mod' under the 'modules' directory
-in the OpenStructure development tree, and populate it with the three subdirectories 'src', 'pymod',
-and 'tests'. Then we add a 'CMakeLists.txt' file in the 'mod' directory, consisting of three lines:
-
- :::cpp
- add_subdirectory(src)
- add_subdirectory(pymod)
- add_subdirectory(tests)
-
-## The module code
-
-In the 'src' subdirectory we put the code that implements the functionality of the new module,
-plus a 'config.hh' header file.
-
-Here is a skeleton of one of the files in the directory , 'modeling\_new\_class\.hh':
-
- :::cpp
- #ifndef OST_MOD_NEW_CLASS_H
- #define OST_MOD_NEW_CLASS_H
-
- #include <ost/mol/entity.hh>
-
- // All other necessary includes go here
-
- namespace ost { namespace mod {
-
- class NewClass
- {
- public:
- void NewMethod();
-
- // All declarations of NewClass go here
-
- };
-
- }} // namespaces
-
- #endif
-
-And here is the skeleton of the corresponding 'modeling\_new\_class.cc' file:
-
- :::cpp
- #include "modeling_new_class.hh"
-
- using namespace ost::mol;
- using namespace ost::mod;
-
- // All other necessary includes and namespace directives
- // go here
-
- void DLLEXPORT NewClass::NewMethod():
- {
- // Implementation
- }
-
- // Implementation code for NewClass goes here
-
-Obviously, the 'src' directory can contain many files, each implementing classes
-and functions that will end up in the module. In order to build and stage
-the module shared library, a 'CMakeLists.txt' file needs to be written for the
-'src' directory:
-
- :::cpp
- set(OST_MOD_SOURCES
- modeling_new_class.cc
- // All other source files
- )
-
- set(OST_MOD_HEADERS
- modeling_new_class.hh
- // All other header files
- )
-
- module(NAME mod SOURCES "${OST_MOD_SOURCES}"
- HEADERS ${OST_MOD_HEADERS}
- DEPENDS_ON mol mol_alg)
-
-
-The line containing the 'DEPENDS ON' directive lists all the modules on which
-the new module depends (in this case 'mol' and 'mol.alg'). The 'module' macro
-will take care of staging the headers, in this case into 'ost/mod' and compiling,
-linking and staging of a library with the name 'libost_mod.so' ('libost_gmod.dylib' on MacOS X).
-
-Note
-: Due to a limitation in the built-int install command of CMake, for modules
- that have their headers in several directories, it is required to group the
- headers by directory, leading to a call of module like:
-
- :::cpp
- module(NAME mol SOURCES atom_handle.cc impl/atom_impl.cc
- HEADERS atom_impl.hh IN_DIR impl
- atom_handle.hh)
-
-The 'config.hh' header is required for each module to setup the environment on
-Windows: Each public class, method and function needs to marked with
-'DLLEXPORT' or 'DLLIMPORT' to teach the linker where to look for the symbol.
-The correct use of either 'DLLIMPORT' and 'DLLEXPORT' is depending on the
-context: While compiling a header file that is part of the same shared
-library, 'DLLEXPORT' must be used. When compiling a header that is part of
-an external shared library, 'DLLIMPORT' must be used. A typical module_config
-header looks like this:
-
- :::cpp
- #ifndef OST_MOD_MODULE_CONFIG_HH
- #define OST_MOD_MODULE_CONFIG_HH
-
- #include <ost/base.hh>
-
- #if defined(OST_MODULE_OST_MOD)
- # define DLLEXPORT_OST_MOD DLLEXPORT
- #else
- # define DLLEXPORT_OST_MOD DLLIMPORT
- #endif
- #endif
-
-## The Testing Framework
-
-The 'tests' directory contains code for Unit Tests. The code is compiled and executed when one invokes
-compilation using the 'make check' command. Tests are run by means of the ['Boost Test Library'](http://www.boost.org/doc/libs/1_37_0/libs/test/doc/html/index.html)
- Framework, which is used throughout OpenStructure. Before coding the test routines, the required skeleton
- needs to be put in place.
-
-The main code is put into 'tests.cc', which will become the test executable:
-
- :::cpp
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- #include "test_modeling.hh"
-
- test_suite*
- unit_unit_test_suite( int argc, char * argv[] ) {
- std::auto_ptr<test_suite> test(BOOST_TEST_SUITE( "Module Mod Test" ));
-
- test->add(CreateModelingTest());
-
- return test.release();
- }
-
-
-The most relevant line adds the test suite for the new module to the global test list.
-The test suite is created by the factory function CreateModelingTest(), which is declared in
-the 'test_modeling.hh' header file.
-
- :::cpp
- #ifndef OST_MOD_TEST_MODELING_H
- #define OST_MOD_TEST_MODELING_H
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- test_suite* CreateModelingTest();
-
- #endif
-
-The definition of the factory function is found in the actual test code,
-which we put in 'test\_modeling.cc'. Here is a skeleton version of that file:
-
- :::cpp
- #include "test_modeling.hh"
-
- // additional include statements will go here
-
- namespace test_modeling {
-
- void test()
- {
- // test code will go here
- }
-
- }
-
- test_suite* CreateModelingTest()
- {
- using namespace test_modeling;
- test_suite* ts=BOOST_TEST_SUITE("Modeling Test");
- ts->add(BOOST_TEST_CASE(&test));
-
- return ts;
- }
-
-In this file, all the normal 'Boost Test Library' macros and functions can be used.
-(For example 'BOOST\_CHECK', 'BOOST\_FAIL', etc.)
-
-Here is finally the build script skeleton that needs to be put into 'mod/tests/':
-
- :::cpp
- set(OST_MOD_UNIT_TESTS
- tests.cc
- test_modeling.cc
- )
-
- ost_unittest(mod "${OST_MOD_UNIT_TESTS}")
- target_link_libraries(ost_mol ost_mol_alg ost_mod)
-
-In the last line the call to the 'target\_link\_libraries'
-function contains the names of the modules on which the 'mod' unit test code depends
-(in this case, the 'mol' and 'mol\_alg' modules) , in addition to the 'mod' module itself.
-
-## The python wrapper
-
-FInally, the module API is exported to Python using the [Boost Python Library](http://www.boost.org/doc/libs/1_37_0/libs/python/doc/index.html).
-In 'mod/pymod', the wrapper code for the classes in the new module is put into a file named 'wrap\_mod.cc':
-
- :::cpp
- #include <boost/python.hpp>
- using namespace boost::python;
-
- #include <ost/mod/modeling_new_class.hh>
-
- using namespace ost::mol;
- using namespace ost::mod;
-
- // All other necessary includes and namespace directives
- // go here
-
- BOOST_PYTHON_MODULE(_mod)
- {
- class_<NewClass>("NewClass", init<>() )
- .def("NewMethod", &NewClass::NewMethod)
- ;
-
- // All other Boost Python code goes here
- }
-
-The 'mod/pymod' directory must obviously contatin a 'CMakeLists.txt' file:
-
- :::cpp
- set(OST_MOD_PYMOD_SOURCES
- wrap_mod.cc
- )
-
- pymod(NAME mod OUTPUT_DIR ost/mod
- CPP ${OST_MOD_PYMOD_SOURCES} PY __init__.py)
-
-The directory should also contain an '\_\_init.py\_\_' file with the
-following content:
-
- :::python
- from _mod import *
-
-In case one wants to implement Python-only functionality for the new module, any
-number of function definitions can be added to the '\_\_init.py\_\_' file.
-
-That's it!. The next time the OpenStructure project is compiled, the new module will
-be built and made available at both the C++ and the Python level.
diff --git a/website/raw/docs/tut/pythonshell.mkdown b/website/raw/docs/tut/pythonshell.mkdown
deleted file mode 100644
index cbea008c19e216c230116821b2de93ec58eed008..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/pythonshell.mkdown
+++ /dev/null
@@ -1,27 +0,0 @@
-title: Python Shell
-
-[TOC]
-
-# The Python Shell
-OpenStructure has a powerful Python Shell which has some handy features. It is completely integrated into OpenStructure and allows you enter Python code.
-
-## Multi line detection
-The Python Shell detects automatically if a code block is complete or not.
-For example a simple print statement in the command line is a complete code block. Therefore the code will be executed after pressing enter:
-
-
-
-When a multiline codeblock (like a for loop or an if instruction) is being entered in the command line, the code is not executed until the code block is complete:
-
-
-
-When a code block is not complete, pressing enter appends an empty line at the end of the code block. To execute such a code block, you simply have to press enter twice.
-
-## Auto completion
-After pressing tab in the Python Shell, it returns you possible extensions to your entered text. This feature can be used for completing variable names or functions:
-
-
-
-It is also possible to complete a file system path string. By pressing tab while editing a string, the shell displays all file or folders of the given directory:
-
-
diff --git a/website/raw/docs/tut/query.mkdown b/website/raw/docs/tut/query.mkdown
deleted file mode 100644
index d48719bdcd2d93e17b3acf2b867a93bb2e68e226..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/query.mkdown
+++ /dev/null
@@ -1,125 +0,0 @@
-[TOC]
-
-# Queries
-
-
-## The Basics
-
-It is often convenient to highlight or focus certain parts of the structure.
-OpenStructure includes a powerful query system that allows you to perform custom
-selections in a convenient way.
-Selections are carried out mainly by calling the Select method made available by EntityHandle and EntityView objects while providing a query string. Queries are written using a dedicated mini-language. For example, to select all arginine residues of a given structure, one would write:
-
- ::::python
- arginines=model.Select('rname=ARG')
-A simple selection query (called a predicate) consists in a property (here, `rname`), a comparison operator (here, `=`) and an argument (here, `ARG`). The return value of a Select method is always an EntityView. The EntityView always contains a full hierarchy of elements, never standalone separated elements. In the above example, the EntityView called `arginines` will contain all chains from the structure called 'model' that have at least one arginine. In turn these chains will contain all residues that have been identified as arginines. The residues themselves will contain references to all of their atoms. Of course, queries are not limited to selecting residues based on their type, it is also possible to select atom by name:
-
- ::::python
- c_betas=model.Select('aname=CB')
-As before, c`betas is an instance of an EntityView object and contains a full hierarchy. The main difference to the previous example is that the selected residues do not contain a list of all of their atoms but only the C-beta. These examples clarify why the name 'view' was chosen for this result of a Select statement. It represents a reduced, restrained way of looking at the original structure.
-
-Both the selection statements that have been used so far take strings as their arguments. However, selection properties such as `rnum` (residue number), take numeric arguments. With numeric arguments it is possible to use identity operators ( `!=` and `=`). It is also possible to compare them using the `>`, `<`, `>=` and `<=` operators. For example, the 20 N-terminal residues of a protein can be selected with:
-
- ::::python
- n_term=model.Select('rnum<=20')
-## Combining predicates
-
-Selection predicates can be combined with boolean operators. For example , you might want to select all C atoms with crystallographic occupancy higher than 50. These atoms must match the predicate `ele=C` in addition to the predicate `occ>50`. In the query language this can be written as:
-
- ::::python
- model.Select('ele=C and occ>50')
-Compact forms are available for several selection statements. For example, to select all arginines and aspargines, one could use a statement like:
-
- ::::python
- arg_and_asn=model.Select('rname=ARG or rname=ASN')
-
-However, this is rather cumbersome as it requires the word `rname` to be typed twice. Since the only difference between the two parts of the selection is the argument that follows the word `rname`, the statement can also be written in an abbreviated form:
-
- ::::python
- arg_and_asn=model.Select('rname=ARG,ASN')
-Another example: to select residues with numbers in the range 130 to 200, one could use the following statement
-
- ::::python
- center=model.Select('rnum>=130 and rnum<=200')
-or alternatively use the much nicer syntax:
-
- ::::python
- center=model.Select('rnum=130:200')
-This last statement is completely equivalent to the previous one. This syntax can be used when the selection statement requires a range of integer values within a closed interval.
-
-## Distance Queries
-
-
-The query
-
- ::::python
- around_center=model.Select('5 <> {0,0,0}')
-selects all chains, residues and atoms that lie with 5 Å to the origin of the reference system ({0,0,0}). The `<>` operator is called the ‘within’ operator.
-Instead of a point, the within statements can also be used to return a view containing all chains, residues and atoms within a radius of another selection statement applied to the same entity. Square brackets are used to delimit the inner query statement.
-
- ::::python
- around_hem=model.Select('5 <> [rname=HEM]')
- model.Select('5 <> [rname=HEM and ele=C] and rname!=HEM')
-
-## Bonds and Queries
-
-When an EntityView is generated by a selection, it includes by default only bonds for which both connected atoms satisfy the query statement. This can be changed by passing the parameters `EXCLUSIVE_BONDS` or `NO_BONDS` when calling the Select method. `EXCLUSIVE_BONDS` adds bonds to the EntityView when at least one of the two atoms falls within the boundary of the selection. `NO_BONDS` suppresses the bond inclusion step completely.
-
-## Whole Residue Queries
-
-If the parameter `MATCH_RESIDUES` is passed when the Select method is called, the resulting EntityView will include whole residues for which at least one atom satisfies the query. This means that if at least one atom in the residue falls within the boundaries of the selection, all atoms of the residue will be included in the View.
-
-## More Query Usage
-
-The high level interface for queries are the Select methods of the
-EntityHandle and EntityView classes. By passing in a query string, a view
-consisting of a subset of the elements is returned.
-
-Queries also offer a second interface: `IsAtomSelected()`,
-`IsResidueSelected()` and `IsChainSelected()` take an atom, residue or
-chain as their argument and return true or false, depending on whether the
-element fulfills the predicates.
-
-Read more about queries in the [query language reference](dox/html/query.html)
-
-## Special Topics
-
-### Distance-based selections
-
-Distance-based selections within a given atom position are supported by the ‘within’ operator (`<>`) . To select atoms within 5 Angstrom of the point `{1,2,3}`, one would write:
-5 <> {1,2,3}To select atoms which lie at a distance further than 5 Angstrom one would use the negation operator:
-
- not 5 <> {1,2,3}
-
-### Compact forms
-
-Instead of writing:
-`aname=CA or aname=C or aname=O or aname=N` one can write:
-
-aname=CA,N,C,OFor integer value ranges, one can use the colon syntax. Instead of `rnum>=10 and rnum<=20` one can write `rnum=10:20`.
-
-
-## Constructing views manually
-
-
-Sometimes the query language is not enough. For these cases the construction of manual entities becomes neccessary. This is pretty straight forward. Starting off with an empty view, bonds, atoms, residues and chains can be added at will.
-
- ::::python
- view=ent.CreateEmptyView()
-To populate the entity view, use one of the EntityView.AddResidue(), EntityView.AddChain(), EntityView.AddAtom() and EntityView.AddBond() member functions:
-
- ::::python
- ca=ent.FindAtom('A', mol.ResNum(1), 'CA')
- view.AddAtom(ca)
-This call will automatically insert the residue and the chain of the atom into the view, so `GetChainCount()`, `GetResidueCount()` and `GetAtomCount()` will all return 1.
-
-To add a residue, use
-
- ::::python
- res=ent.FindResidue('A', mol.ResNum(1))
- view.AddResidue(res)
-This will not add any atoms. To add the atoms, pass `mol.INCLUDE`ATOMS` to AddResidue:
-
- ::::python
- view.AddResidue(res, mol.INCLUDE_ATOMS)
-Due to performance reasons, all of the add method do not check for duplicates by default. To turn duplicate-checking on, pass `mol.CHECK`DUPLICATES` as the second argument.
diff --git a/website/raw/docs/tut/sel.png b/website/raw/docs/tut/sel.png
deleted file mode 100644
index e5b3c80252ac121d9ec3a56f3730dbda8e91356d..0000000000000000000000000000000000000000
Binary files a/website/raw/docs/tut/sel.png and /dev/null differ
diff --git a/website/raw/docs/tut/tut02.mkdown b/website/raw/docs/tut/tut02.mkdown
deleted file mode 100644
index 55417178aec476597af4e6811953ff07feca2ae7..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/tut02.mkdown
+++ /dev/null
@@ -1,160 +0,0 @@
-[TOC]
-# Exercises
-
-## Queries and Views
-
-First load myo.pdb. This can be done by either loading it in the file browser, or by loading it manually in the python shell.
-
-## Loading manually
-
-
- myo=io.LoadPDB(‘myo.pdb’)
- myo_go=gfx.Entity(‘Myo’, myo)
- scene.Add(myo_go)
- scene.SetCener(myo_go.GetCenter())
-
-## Loading in the file browser
-
-Double click the file in the file browser. Now we have to get our hands on the myo object from the python shell:
-
- myo_go=scene[‘myo’]
- myo=myo_go.view.GetHandle()
-
-To display your views as a halo around the myo object, use
-
- myo_go.current_selection=whatever_view
- # or
- myo_go.SetCurrentSelection(whatever_view)
-
-
-Now go ahead and try to create the following selections. Not all of them can be solved by using selection statements. 1-4 and 7 can be solved by using selection statements alone, but 5 and 6 require you to create views manually.
-
-* Select all atoms of the HEM residue
-* Select carbon atoms of the HEM residue
-* Select the atoms within 8.0A of the HEM by using a selection statement.
-* Select all atoms of residues for which at least one atom is within 8.0A
- of the HEM
-* Select the atoms within 8.0A of the HEM by using EntityHandle.FindWithin().
- This method takes a position and a radius and returns a list of atoms that are
- within the given distance of the point. These have then to be assembled into a
- view by populating an initially empty view as described in “Manually
- Constructing Views”.
-* Assemble a view that contains C-beta atoms for residues that have a CB and CA
- for residues that don't have a CB. To find out, if a certain residue has an
- atom, call residue.FindAtom(atom_name) and check if the returned atom is
- valid,i.e
-
- ca=residue.FindAtom(‘CA’)
- if ca.IsValid():
- print ca
- else:
- print residue, ‘does not have a CA’
-
-* Select sidechains of residues for which at least one atom is within 8.0A of
- the HEM
-
-## Writing a Parser for your own file format
-
-
-In this exercise you will learn how to build and entity from the ground up by writing a parser for a custom file format. The skeleton of the parser can be found in 02_conop.py. Your task is to fill-in the missing parts. To do so, you will be first creating an empty entity (mol.CreateEntity()) and then assemble the entity with an XCSEditor.
-
-But first some background on what editors are:
-
-## Editors
-
-The structure, topology and connectivity of entities is edited via editors. This includes operations such as changing atom positions, connecting atoms with bonds as well as adding and removing chains, residues and atoms. To insert a new chain, append a residue or insert an atom, use EditorBase.InsertChain, EditorBase.AppendResidue or EditorBase.InsertAtom, respectively.
-
-You can create an editor by calling
-
- edi=ent.RequestXCSEditor()
-
-on your entity. Adding chains, residues and atoms is pretty straigh-forward:
-
- chain=edi.InsertChain(chain_name)
- gly=edi.AppendResidue(chain, “GLY”)
- edi.InsertAtom(gly, “N”, geom.Vec3())
- edi.InsertAtom(gly, “CA”, geom.Vec3())
- edi.InsertAtom(gly, “C”, geom.Vec3())
- edi.InsertAtom(gly, “O”, geom.Vec3())
-
-You might have noticed that the above code snippet does not add any bonds, nor does it fill any atom properties such as element, radius and so on. OpenStructure has a module dedicated to only do that: The conop module. After importing it, a single call is sufficient to connect the atoms, fill in residue and atom properties:
-
- conop.ConnectAll(ent)
-
-### Editor for external coordinate system
-
-The XCSEditor defines the interface for manipulating the external coordinate system. The external coordinate system directly operates on atom positions in euclidian space. A specific atom position can be changed with XCSEditor.SetAtomPos. XCSEditor.ApplyTransform applies a transformation to all atoms.
-
-###Editor for internal coordinate system
-
-The ICSEditor is used to manipulate the internal coordinate system that is defined by bond lengths and angles. By default the internal coordinate system is not calculates. However, upon requesting an ICSEditor for the first time, the internal coordinate system is initialized. This involves the build-up of a directed-graph for the bond network as well as calculating the internal coordinate matrices.
-
-The use XCSEditor and ICSEditor are mutually exlusive. This means that whenever a XCSEditor has pending changes, the results of using an ICSEditor is undefined and vice versa.
-
-
-## Processing of Density Maps
-
-In this exercise you will learn how to do basic processing of density map data. For the exercise you will use real experimental data coming from a single particle reconstruction of the YscC protein from Yersinia entercolitica.
-
-The first step to the processing of density data in OpenStructure is the loading of the ‘img’ and ‘img.alg’ module.
-Go ahead and load the module in the OpenStructure python shell.
-
-The second step consists in loading the density data into memory. OpenStructure provides a LoadMap function in the ‘io’ module that can be used, not surprisingly, to load a density map.
-map=io.LoadMap(‘YscC.spi')The file is in Spider format( Spider is one of the most celebrated software packages for single particle reconstruction).
-
-The dataset is very big and is stored in a large density map. It will take a few seconds to load. To find out how large the density map is, you can use the interface of the ImageHandle object used to store the image. The interfaces provides functions to get several items of information about the map:
-
- print map.GetSize()
- print map.GetAbsoluteOrigin()
- print map.GetSpatialOrigin()
- print map.GetSpatialSampling()
- print map.GetExtent()
-
-This last command returns an Extent object containing additional information about the extent of the map. Its interface can be used to learn even more.
-
- print map.GetExtent().GetStart()
- print map.GetExtent().GetEnd()
- print map.GetExtent().GetCenter()
-
-You will notice that the GetSpatialSampling method shows that the map has a pixel sampling of 1 Angstrom in all directions. This is not correct. The correct pixel sampling information was not saved on disk. Let’s go ahead and set it manually: it is 2 Angstrom in all directions, so:
-
- map.SetSpatialSampling(2.0*Units.A)
-
-The map is way too large to be manipulated and visualized comfortably. Since the data have low resolution anyway, we will shrink the map using the DiscreteShrink algorithm.
-
-First, go ahead and import the `img.alg` module.
-
-Then let’s create an instance of the DiscreteShrink algorithm. Let’s pass it a size parameter of 4x4x4. The map will be shrunk by a factor of 4 in all directions.
-Let’s now apply the algorithm to the map. We apply it in place, because we want to overwrite the original data
-map.ApplyIP(shrink_alg)Now go ahead and try to recover the information about the spatial sampling from the map. Verify that the pixel sampling has been adjusted to reflect the shrinking.
-shrink_alg=img.alg.DiscreteShrink(img.Size(4,4,4))
-
-Now, let’s use another algorithm to normalize the density values of the map between the 0 and 1
-norm=img.alg.CreateLinearRangeNormalizer(map,0.0,1.0)When you create an instance of this algorithm, you need to pass it information about the map it will be applied to (map) and the lowest and highest value of the normalization range(0.0 and 1.0)
-
-The algorithm can then be applied to the map. Go ahead and apply it in place, overwriting the original data.
-
-In order to visualize the map, we are now going to create an iso-surface graphical object
-map_go=gfx.MapIso(“map”,map,0.5)This will create a an iso-surface graphical object based on the object “map”, drawing the iso-surface at a threshold level of 0.5. The object will appear in the scene menu with the name “map”.
-
-The graphical object needs to be now added to the scene and center the scene on the object
-scene.Add(map_go)
-scene.SetCenter(map_go.GetCenter())Tah-da! There it is on the screen! If you now select the “map” object in the scene menu, and press the “M” button beside the scene view, you can change the iso-surface threshold interactively. You do this by keeping the ‘command’ key on Mac Computers (or the ‘Control’ key on Linux) and moving the mouse to the left or to the right.
-
-You can always get value of the current iso-surface threshold level using the interface of the graphical object:
-print map_go.GetLevel()
-Finally, let’s create a low-pass-filtered version of the map and display it on the screen.
-We use the LowPassFilter algorithm:
-
-filter=img.alg.LowPassFilter(4.0*Units.nm)
-
-We pass to the algorithm the resolution threshold for the filtering. Please notice that we pass it in nanometers, because we have been working with electron tomography in the past, so it comes easier to us to think in terms of nanometers as opposed to Angstrom. OpenStructure does the necessary conversion internally.
-
-Now let’s apply the algorithm, but this time let’s do it out of place to create a new map.
-
-filtered_map=map.Apply(filter)
-
-Please now go ahead and create a graphical object for this map, give it an appropriate threshold, the name “filtered_map” and add it to the scene. Then play with the iso-surface.
-
-Congratulations, you have completed the exercise!
-
diff --git a/website/raw/docs/tut/vecmath.mkdown b/website/raw/docs/tut/vecmath.mkdown
deleted file mode 100644
index d4bf338a978776f31f7c892574501837b6d82c61..0000000000000000000000000000000000000000
--- a/website/raw/docs/tut/vecmath.mkdown
+++ /dev/null
@@ -1,96 +0,0 @@
-title: Vector Math in OpenStructure
-
-[TOC]
-
-# Vector Math in OpenStructure
-
-## Vector Math
-
-OpenStructure has built-in support for vectors in 2,3 and 4 dimension. They are called
-'Vec2', 'Vec3' and 'Vec4' respectively. You can use the vector classes like in a math formula:
-You can add them together, multiply them by scalar values or calculate the inner and outer
-product. This short code snippet gives an idea of how you can use vectors.
-
- :::python
- a=geom.Vec2(1,0)
- b=geom.Vec2(0,1)
- # print the vectors
- print a,b
-
-Here is another example:
-
- :::python
- # create a new vector by using components of both a and b.
- # The components of a vector can be accessed by using the
- # array subscript notation:
- c=geom.Vec2(a[0],b[1])
- # print length of vector a and b
- print geom.Length(a), geom.Length(b)
-
- # calculate dot (inner) product
- print geom.Dot(a,b)
-
- # do some fancy calculation
- d = a+2*b
- print '%s+2*%s is %s' % (a,b,d)
-
-In the same tokens, you can use 3 and 4-dimensional vectors. If you want to
-calculate the angle between two vectors, you can use the properties of the
-inner product: Calculating the inner product of two unit-length vectors is
-identical to the cosine of the angle between the two vectors. But the 'geom'
-library also offers a function to directly compute the Angle between two vectors.
-Here are examples of both approaches:
-
- :::python
- # the standard python math module defines the pi constant and the acos function
- import math
- angle= math.acos(geom.Normalize(c),geom.Normalize(d))*180.0/math.pi
- # computing the angle using the geom.Angle function
- angle2=geom.Angle(c,d)
-
-## Linear Transforms
-
-Linear transforms, such as scaling and rotation of vectors, can be achieved easily.
-
-### Rotation
-
-Rotations are usually carried out using quaternions or rotation matrices. There
-are several helper classes in OpenStructure that encapsulate the logic of rotation.The
-'Rotation3' class represents a rotation in 3D space defined by 3 Euler angles. Please
-notice that although the class requires to be initialized with radiants, one can use
-the Units function to express the value using any homogenous unit (for example, degrees)
-and the conversion will be done automatically. The Units function is available in all OpenStructure modules.
-
- :::python
- # define rotation around x axis by 180 degrees (PI radians)
- rot=geom.Rotation3(math.pi,0,0)
- # define the same rotation explicitly using radiant units
- # this is equivalent to the line above
- rot=geom.Rotation3(math.pi*Units.rad,0,0)
- # define the same rotation using angle units (again equivalent)
- rot=geom.Rotation3(180.0*Units.deg,0,0)
- rot=geom.Rotation3(math.pi)
- # define the same rotation using the Units
- v=geom.Vec3(0,1,0)
- # rotate v by rot
- print rot.GetRotationMatrix()*v
-
-In two dimensions, the 'Rotate' function can be used to rotate a vector by a certain amount
-
- :::python
- #rotate by 90 degrees (PI/2 radians)
- print geom.Rotate(geom.Vec2(1,0),math.pi/2)
-
-
-### Scaling
-
-Uniform vector scaling can be accomplished by multiplication of the vector by a
-scalar factor. For non-uniform scaling you can use a 3x3 matrix with all but the
-main diagonal elements set to zero.
-
- :::python
- scale=geom.Mat3(1.0,0.0,0.0,
- 0.0,2.0,0.0,
- 0.0,0.0,4.0)
-
- print scale*geom.Vec3(1,1,1)
diff --git a/website/raw/docs/tutorials.mkdown b/website/raw/docs/tutorials.mkdown
deleted file mode 100644
index 11b73983f54388258ab36df2dac7b02352ba54d9..0000000000000000000000000000000000000000
--- a/website/raw/docs/tutorials.mkdown
+++ /dev/null
@@ -1,29 +0,0 @@
-title: Tutorials
-
-# Tutorials
-
-## For Users
-
- * [Introduction](docs/tut/intro.html)
- * [Vector Math in OpenStructure](docs/tut/vecmath.html)
-
-### User Interface
- * [Graphical User Interface](docs/tut/gui.html)
- * [Python Shell](docs/tut/pythonshell.html)
-
-### Molecular Datasets
- * [The query language](docs/tut/query.html)
- * [Connecting Atoms - Conopology](dox/html/module_conop.html)
- * [Storing Custom Data in an Entity](docs/tut/genericprop.html)
-
-### Images and Density Maps
- * [Images / Density Maps - An Introduction](docs/tut/imgintro.html)
- * [Algorithms for Images and Density Maps](docs/tut/imgalg.html)
- * [The Data Viewer](docs/tut/imgdataviewer.html)
-
-
-## For Developers
- * [Expanding OpenStructure - Creating a New Module](docs/tut/newmodule.html)
- * [Using External Programs within OpenStructure](docs/tut/external.html)
- * [Creating new algorithms for Images and Density Maps](docs/tut/imgalgdata.html)
- * [Creating new image state algorithms](docs/tut/imgalgdistate.html)
diff --git a/website/raw/download.mkdown b/website/raw/download.mkdown
deleted file mode 100644
index 01c07bcdf8ebdc4978d64ffb79f17fc87c5af23a..0000000000000000000000000000000000000000
--- a/website/raw/download.mkdown
+++ /dev/null
@@ -1,15 +0,0 @@
-title: Download
-
-[TOC]
-
-# Download
-
-Please choose your platform
-
-Current Version: 1.0.0.a
-
- * [Windows](windowsdownload.html)
- * [MacOS X 10.5 or later](macdownload.html)
- * [Linux](linuxdownload.html)
-
-
diff --git a/website/raw/features.mkdown b/website/raw/features.mkdown
deleted file mode 100644
index d3c3118e545157d8c66e405ab23366f372d53fa0..0000000000000000000000000000000000000000
--- a/website/raw/features.mkdown
+++ /dev/null
@@ -1,59 +0,0 @@
-title: Features
-
-# Features
-
-## General Features
-
- * Cleanly designed API available in both <a target="extern" href="http://www.python.org">Python</a> an C++
- * command line interface for batch processing
- * graphical user interface that is completely scriptable from Python.
-
-## License
-
- OpenStructure is released under the <a target="extern" href="http://www.gnu.org/licenses/lgpl-3.0-standalone.html">LGPL Version 3</a> license.
-
-## Supported Platforms
-
- * [Windows](windowsdownload.html)
- * [MacOS X](macdownload.html)
- * [Linux](linuxdownload.html)
-
-## Macromolecules
-
- * Rich understanding of macromolecular structure datasets.
- * Support for common file formats.
-
-## 2D Images and Density Maps
-
- * Image processing tools for both 2-dimensional images and 3-dimensional density maps (Masks,
- real and Fourier space filters, correlation).
- * Support for the most common formats
- used in the fields of x-ray, electron crystallography, and atomic force microscopy.
-
-## Supported File Formats
-
-### Molecules
-
- * Brookhaven Database <a target="extern" href="http://www.wwpdb.org/docs.html">PDB</a>
- * <a target="extern" href="http://www.poissonboltzmann.org/file-formats/biomolecular-structurw/pqr">PQR</a>
- * Structure Data File <a target="extern" href="http://www.symyx.com/solutions/white_papers/ctfile_formats.jsp">SDF</a>
-
-### Image/Map Formats
-
- * <a target="extern" href="http://www.libtiff.org/">TIFF</a>
- * <a target="extern" href="http://www.libpng.org/">PNG</a>
- * <a target="extern" href="http://ami.scripps.edu/software/mrctools/mrc_specification.php">MRC</a>/<a target="extern" href="http://2dx.org/">2dx</a>[]()
- * <a target="extern" href="http://www.ccp4.ac.uk/">CCP4</a>
- * <a target="extern" href="http://situs.biomachina.org/">Situs</a>
- * <a target="extern" href="http://www.wadsworth.org/spider_doc/spider/docs/spider.html">Spider</a>
- * <a target="extern" href="http://www.jpk.com/index.2.en.html">JPK</a>
- * <a target="extern" href="http://www.gatan.com/imaging/dig_micrograph.php">Digital Micrograph</a>
- * <a target="extern" href="http://www.veeco.com/">Nanoscope</a>
-
- Binary formats can be read and saved in both little and big endianness.
-
-### Sequence/Alignment Formats
-
- * <a target="extern" href="http://mcast.sdsc.edu/doc/clustalw-format.html">ClustalW</a>
- * <a target="extern" href="http://en.wikipedia.org/wiki/FASTA_format">Fasta</a>
- * Promod (Swiss PDB-Viewer)
diff --git a/website/raw/gallery.mkdown b/website/raw/gallery.mkdown
deleted file mode 100644
index 918b476edf9cc98284c33e0fb5fb5470cf8f0cab..0000000000000000000000000000000000000000
--- a/website/raw/gallery.mkdown
+++ /dev/null
@@ -1,9 +0,0 @@
-title: Gallery
-
-# Gallery
-| | |
-| - | - |
-| [](100212_Loops.png "Loop Modelling")| [](100212_BE_Score.png "BE Score") |
-| [](100212_Openstructure1.0a1_1622_Mac.png "Screenshot Mac OS") | [](surface_windows7.PNG "Screenshot Windows Surface")|
-| [](100611_Screenshot_Linux.png "Screenshot Linux") | [](map_windows7.PNG "Screenshot Windows Map")|
-| [](100611_Screenshot_Windows.png "Screenshot Windows")||
\ No newline at end of file
diff --git a/website/raw/index.mkdown b/website/raw/index.mkdown
deleted file mode 100644
index 41115478ba33aa810d18e6b1a6f098ab02c64e65..0000000000000000000000000000000000000000
--- a/website/raw/index.mkdown
+++ /dev/null
@@ -1,14 +0,0 @@
-title: Welcome to OpenStructure
-
-
-# Welcome to OpenStructure
-
-This project aims to provide an open-source, modular, flexible, molecular modelling and visualization environment. It is targeted at interested users and method developers in the field of structural bioinformatics.
-
-
-
-Interested? Then have a look at the [features](features.html) list.
-
-## Getting Started
-
-For users new to OpenStructure, we have prepared an [introduction to the framework](docs/tut/intro.html), a bunch of [tutorials](docs/tutorials.html) and [examples](docs/examples.html) that will help you getting started. For people that are already familiar with the basics, the [API documentation](dox/html/classes.html) provides detailed information on different topics in and around OpenStructure.
diff --git a/website/raw/linuxdownload.mkdown b/website/raw/linuxdownload.mkdown
deleted file mode 100644
index 0cf6b68d681f8697004dc7906ef463e08d29ac91..0000000000000000000000000000000000000000
--- a/website/raw/linuxdownload.mkdown
+++ /dev/null
@@ -1,63 +0,0 @@
-title: Download - Linux
-
-[TOC]
-
-# Download - Linux
-
-OpenStructure is released under the <a target="extern" href="http://www.gnu.org/licenses/lgpl-3.0-standalone.html">LGPL Version 3</a> license.
-
- * [OpenStructure Linux Bundle - Ubuntu 10.04 (Lucid Lynx) and later](downloads/openstructure-lucid-32bit.tgz)
- * [OpenStructure Linux Bundle - Ubuntu 9.10 (Karmic Koala) and earlier](downloads/openstructure-karmic-32bit.tgz)
-
-Each of these archives contains a stand-alone self-contained version of OpenStructure supporting [various Linux distributions](linuxdownload.html#platforms).
-
-To run it, follow this simple instructions:
-
-1. Unpack the archive. If you are using a graphical desktop manager (like Gnome or KDE), this can be done by
-clicking on the file and selecting the appropriate option in the archiving tool application. If you are using
-a command line terminal, type:
-
- :::bash
- tar xvfz <archive name>
-
-2. Open a terminal and move to the package directory:
-
- :::bash
- cd <directory name>
-
-3. Launch the graphical front end 'DNG':
-
- :::bash
- ./dng
-
- Or the OpenStructure console 'ost'
-
- :::bash
- ./ost
-
-Note
-: These packages have been created on a 32bit machine (but should work also on 64 bit machines, provided
-that the correct 32-bit compatibility libraries are installed).
-
-
-Although the file archives have been created using the Ubuntu linux distribution, they have also been tested on
-other systems.
-<a id="platforms"/>
-The Karmic file archive has been tested on the following Linux distributions:
-
-* Ubuntu 9.10
-* Ubuntu 9.04
-* Ubuntu 8.10
-* Fedora Core 12
-* Fedora Core 11
-* Fedora Core 10
-* CentOS 5.5
-
-The Lucid file archive has been tested on the following Linux distributions:
-
-* Ubuntu 10.04
-* Fedora Core 13
-
-The archives do not contain drivers for the graphic card on your machine. In order to fully appreciate
-the OpenStructure experience, you have to install the graphic drivers yourself and activate 3D acceleration.
-This procedure in distribution and architecture specific, so it can not be described in details here.
diff --git a/website/raw/logo.png b/website/raw/logo.png
deleted file mode 100644
index ecba6de631774fbe6468c15825be9709f1663e90..0000000000000000000000000000000000000000
Binary files a/website/raw/logo.png and /dev/null differ
diff --git a/website/raw/loops.png b/website/raw/loops.png
deleted file mode 100644
index fc49942dbbd76df5bedf540a2280a43a8598b9e9..0000000000000000000000000000000000000000
Binary files a/website/raw/loops.png and /dev/null differ
diff --git a/website/raw/macdownload.mkdown b/website/raw/macdownload.mkdown
deleted file mode 100644
index 57a79f8af7209bfc5ab96902757627e54af65da1..0000000000000000000000000000000000000000
--- a/website/raw/macdownload.mkdown
+++ /dev/null
@@ -1,19 +0,0 @@
-title: Download MacOS X
-
-[TOC]
-
-# Download - MacOS X
-
-OpenStructure is released under the <a target="extern" href="http://www.gnu.org/licenses/lgpl-3.0-standalone.html">LGPL Version 3</a> license.
-
-## Install It
- * [Download the package](downloads/OSTcurrent_macos.pkg). It contains a
- full-fledged version of OpenStructure. *Important*: You need MacOS 10.5 or
- later to run OpenStructure.
-
- * Doubleclick the package to start the installation
-
-## Run It
-
- * Run DNG in /Applications/OpenStructure. You can find some example scripts in
- /Applications/OpenStructure/Examples
\ No newline at end of file
diff --git a/website/raw/map_windows7.PNG b/website/raw/map_windows7.PNG
deleted file mode 100644
index 4f6661ffe1fbafca4bb22d62463d0a5c5db77655..0000000000000000000000000000000000000000
Binary files a/website/raw/map_windows7.PNG and /dev/null differ
diff --git a/website/raw/map_windows7_TN.PNG b/website/raw/map_windows7_TN.PNG
deleted file mode 100644
index faef6b399371a692017f57a04877a393d2f86f7c..0000000000000000000000000000000000000000
Binary files a/website/raw/map_windows7_TN.PNG and /dev/null differ
diff --git a/website/raw/modules.png b/website/raw/modules.png
deleted file mode 100644
index c4ef4b067c623373ceae40f82657e4831da7fd72..0000000000000000000000000000000000000000
Binary files a/website/raw/modules.png and /dev/null differ
diff --git a/website/raw/scaffold.html b/website/raw/scaffold.html
deleted file mode 100644
index def18f9d64ef318b542eff59e0db0342ae9f47a3..0000000000000000000000000000000000000000
--- a/website/raw/scaffold.html
+++ /dev/null
@@ -1,52 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8">
- <base href="%(BASE)s/">
- <title>%(TITLE)s</title>
- <link rel="stylesheet" type="text/css" href="css/ost.css" media="screen,print" title="Stylesheet" charset="utf-8">
-
-</head>
-<body>
- <div id="content-holder">
- <div id="toc-box">
- <div id="menu">
- <a class="toc-title" >Site Navigation</a>
- <div class="toc-sep">
- <ul>
- <li><a href="index.html">Home</a></li>
- <li><a href="docs/tut/intro.html">Getting Started</a></li>
- <li><a href="features.html">Features</a></li>
- <li><a href="download.html">Download</a></li>
- <li><a href="gallery.html">Gallery</a></li>
- <li><a href="docs/index.html">Documentation</a></li>
- <ul>
- <li><a href="docs/tutorials.html">Tutorials</a></li>
- <li><a href="docs/examples.html">Examples</a></li>
- <li><a href="dox/html/classes.html">Class List</a></li>
- </ul>
- <li><a href="FAQ.html">Frequently Answered Questions</a></li>
-
- <li>
- <a href="ack.html">Acknowledgements</a>
- </li>
- <li>
- <a href="contact.html">Contact</a>
- </li>
- </ul>
- </div>
- <a class="toc-title" >Table of Contents</a>
- <div class="toc-sep" >
- %(SITE_NAV)s
- </div> <!--toc-sep-->
- </div><!--menu-->
- </div><!--toc-box-->
- <div id="content" >
- %(CONTENT)s
- <div id="footer">
- Copyright 2008-2010 by the OpenStructure authors
- </div>
- </div>
- </div>
-</body>
-</html>
diff --git a/website/raw/surface_windows7.PNG b/website/raw/surface_windows7.PNG
deleted file mode 100644
index 3a2bf0e73ea82b3fbcec17c55c0f6b8519bb8d00..0000000000000000000000000000000000000000
Binary files a/website/raw/surface_windows7.PNG and /dev/null differ
diff --git a/website/raw/surface_windows7_TN.PNG b/website/raw/surface_windows7_TN.PNG
deleted file mode 100644
index 1a8fbcfe6b6c8f807f9cb392303c21f10d229bb3..0000000000000000000000000000000000000000
Binary files a/website/raw/surface_windows7_TN.PNG and /dev/null differ
diff --git a/website/raw/windowsdownload.mkdown b/website/raw/windowsdownload.mkdown
deleted file mode 100644
index f32a831db2d7dd493bf6f095b931b5e2866d6f6c..0000000000000000000000000000000000000000
--- a/website/raw/windowsdownload.mkdown
+++ /dev/null
@@ -1,16 +0,0 @@
-title: Download/Installation Instructions for the Windows platform
-
-# Download - Windows
-
-OpenStructure is released under the <a target="extern" href="http://www.gnu.org/licenses/lgpl-3.0-standalone.html">LGPL Version 3</a> license.
-
-## Installation
- 1. [Download](downloads/OSTcurrent_windows.zip) the complete OpenStructure package for windows.
- * Extract the zip archive to your desired folder.
-## Starting DNG - The Graphical User Interface to OpenStructure
- * Simply start DNG by double clicking ***dng.bat*** in the bin directory.
- * Located in the same directory is also ***ost.bat*** a command line interface to the openstructure framework.
-
-## Supported Windows Platforms
-Currently we only offer a 32bit Windows version.
-
diff --git a/website/stylesheet.css b/website/stylesheet.css
deleted file mode 100644
index b1d1a5cda60a612a4243e884965dcbc6332723a3..0000000000000000000000000000000000000000
--- a/website/stylesheet.css
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- alternatives: 005F6A, B84433
- */
-* {
- font-family:Verdana, sans-serif;
- font-size:10pt;
- line-height:14pt;
-}
-body {
- width:100%;
- height:100%;
-}
-#content-holder {
- margin-top:1cm;
- margin-left:auto;
- margin-right:auto;
- width:25cm;
- padding-left:0.2cm;
- background-color:white;
- border-color:#aaa;
- margin-bottom:0.2cm;
- padding-bottom:0.1cm;
-}
-#content {
- border-color:#dddddd;
- border-left-style:solid;
- border-width:1px;
- padding-left:10px;
- float:right;
- width:18cm;
- min-height:20cm;
-}
-code {
- font-family:Inconsolata, monospace;
- border-color:#eeeeee;
- border-width:1px;
- margin:0px;
- background-color:#fafafa;
-}
-
-a[href] {
- color:#B84433;
- font-style:italic;
-}
-
-h1 {
- font-size:200%;
- font-weight:normal;
- color:#B84433;
-}
-
-h1 a {
- font-size:100%;
- font-weight:normal;
- color:#B84433;
-}
-
-h2 {
- font-family:Georgia, serif;
- padding-top:10pt;
- font-size:150%;
- color:#333333;
- font-weight:normal;
- font-style:italic;
-}
-
-h2 a {
- font-family:Georgia, serif;
- padding-top:10pt;
- font-size:100%;
- color:#333333;
- font-weight:normal;
- font-style:italic;
-}
-
-h1, h2, h3 {
- width:15cm;
-}
-#menu {
- /*text-align:right;*/
- padding-top:10px;
- float:left;
- width:6.4cm;
- background: #fff url('../loops.png') no-repeat +26px right;
-}
-#menu a {
- font-style:normal;
-}
-#menu li {
- list-style-type:none;
- padding-bottom:5px;
-}
-#menu ul {
- padding-left:10px;
-}
-table {
- padding:20px;
- margin:0px;
- width:70%;
-}
-.toc {
-}
-.toc ul {
- padding-left:20px;
- /*padding-bottom:5px;*/
-}
-.toc li {
- padding-top:5px;
- list-style-type:none;
-}
-.linenos {
- vertical-align:top;
- font-family:Inconsolata, monospace;
- background-color:#dddddd;
- color:#333333;
- width:20px;
- text-align:right;
- padding-right:2px;
- margin:0px;
- border-width:0px;
-}
-.code {
- font-family:Inconsolata, monospace;
- border-color:#eeeeee;
- border-style:solid;
- border-width:1px;
- border-color:#dddddd;
- display:block;
- padding-left:10px;
- margin:0px;
- background-color:#fafafa;
- width:13cm;
-}
-#footer {
- font-size:8pt;
- color:#333;
- border-color:#dddddd;
- border-width:1px;
- border-top-style:solid;
- vertical-align:bottom;
-}
-
-.code .s {
- color:#B84433;
-}
-
-.code .p {
- color:black;
-}
-
-.code .k {
- color:#4433B8;
-}
-
-
-
-.code .kn {
- color:#4433B8;
-}
-
-.code .n {
- color:#333;
-}
-
-.code .ow {
- color:#4433B8;
-}
-
-.el, .memItemLeft, .memItemRight, .memname, .paramtype, .paramname {
- font-family:Inconsolata, monospace;
-}
-
-.memproto {
- border-top-style:dotted;
- border-top-width:1px;
- border-top-color:#999;
- margin-top:20px;
-}
-
-/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */
-
-
-DIV.tabs
-{
- height:35px;
- padding:0px;
- padding-left:10px;
- color:black;
- text-align:left;
- margin:0px;
- /*background-color:#2471BF;*/
- border-color:#A5ABB9;
- display:block;
- float:none;
- width:15cm;
-}
-
-DIV.tabs UL
-{
- margin : 0px;
- padding:0px;
- /*padding-left : 10px;*/
- list-style : none;
-}
-DIV.tabs LI {
- margin:0px;
- padding:0px;
-}
-
-DIV.tabs LI, DIV.tabs
-{
- float: left;
- margin : 0px;
- padding : 0px;
-}
-
-DIV.tabs FORM
-{
- float : right;
-}
-
-DIV.tabs A
-{
- border-width:1px;
- border-style:solid;
- margin:0px;
- border-color:#A5ABB9;
- padding:3px 5px 3px 5px;
- color:#2471BF;
- background-color:#e8e8e8;
- position:relative;
- text-decoration:none;
- top:-2px;
-}
-
-DIV.tabs A:hover
-{
- background-position: 100% -150px;
-}
-
-DIV.tabs A:link, DIV.tabs A:visited,
-DIV.tabs A:active, DIV.tabs A:hover
-{
- color: #1A419D;
-}
-
-DIV.tabs TD
-{
- font-size : 80%;
- font-weight : bold;
- text-decoration : none;
- margin:0px;
-}
-
-
-
-/* Commented Backslash Hack hides rule from IE5-Mac \*/
-DIV.tabs SPAN {float : none;}
-/* End IE5-Mac hack */
-
-DIV.tabs A:hover SPAN
-{
- background-position: 0% -150px;
-}
-
-DIV.tabs LI.current A
-{
- border-width:1px 1px 1px 1px;
- border-style:solid;
- border-color:#A5ABB9;
- text-decoration:none;
- font-style:normal;
- padding:5px 5px 5px 5px;
- margin:0px;
- color:#2471BF;
- background-color:#fff;
- position:relative;
- top:-4px;
- /*font-weight:bold;*/
-}
-
-DIV.tabs LI.current SPAN
-{
- background-position: 0% -150px;
- padding-bottom : 6px;
-}
-
-.navpath .el {
- text-decoration:none;
-}
-DIV.navpath
-{
- background : none;
- border : none;
- border-bottom : 1px solid #DDD;
- text-align : left;
- margin : 0px;
- padding : 2px;
-}