drawcanvas class added

LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2023 Aaron M. Schinder
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,15 @@
+# amscppsimpledraw
+
+This C++ library is a simple portable renderer. "It turns out you can just draw things." It doesn't depend on any underlying graphics environment, not OpenGL, not any of the newer things. It doesn't depend on any windowing environment. It doesn't depend on having a graphics card - all operations are done threaded on the CPU. (Because of this, it may be slow, but I'm writing it betting that it is fast enough for my purposes).
+
+## Dependencies:
+
+amsmathutil25 - my math and utility libray. It depends on some of the threaded caller wrappers.
+
+amscimglib4 - Low level C image loaders and savers for JPEG, BMP, PNG images. (This is my primary mode of debugging and output at the moment.)
+
+amscppimglib4 - C++ image manipulation routines.
+
+amscppmesh1 - a place where I've stashed various mesh manipulation routines
+
+

amscppsimpledraw.code-workspace

@@ -0,0 +1,16 @@
+{
+	"folders": [
+		{
+			"path": "."
+		},
+		{
+			"path": "../../sourceprojs23/camsimglib3"
+		},
+		{
+			"path": "../../sourceprojs23/amscppfilesys3"
+		},
+		{
+			"path": "../amsmathutil25"
+		}
+	]
+}

backup.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/bash 
+
+tar -czvf ../amscppsimpledraw.tar.gz ./* 
+
+scp ../amscppsimpledraw.tar.gz aschinder@amssolarempire.com:~/workspace/projects 
+

build/amsbuildlib4.py

@@ -0,0 +1,813 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+
+"""
+Copyright Aaron M. Schinder, 2011 - MIT/BSD License
+
+This script contains a bunch of helper functions for generating simple, imperative, hopefully
+transparent build scripts using the python language (and nothing else). 
+
+I just want the script to do the compiling and linking operations I want it to do in the order
+I want it to do it in, finding every relevant source file. 
+
+That's it. That's what I want in a build system.
+"""
+
+def flist(pth,**kwargs): 
+    """
+    flist - list all files in a given directory pth
+    optional arguments:
+       recurse - (T/F): Whether to recursively search for files in directory tree
+       exts - (list): A list of file extensions to search for, otherwise all files
+       normpath (T/F): whether to normalize path variables after
+    filelist = flist(pth,**kwargs): 
+    """
+    flst = []
+    if(not('recurse' in kwargs)):
+        recurse_ = False
+    else:
+        recurse_ = kwargs['recurse']
+    if(not('exts' in kwargs)):
+        filterexts_ = False
+    else:
+        filterexts_ = True
+        exts = kwargs['exts']
+    if(not('normpath' in kwargs)):
+        normpath_ = True
+    else:
+        normpath_ = kwargs['normpath']
+    if(not('linuxpath' in kwargs)):
+        linuxpath_ = False
+    else:
+        linuxpath_ = kwargs['linuxpath']
+    if(not('followlinks' in kwargs)):
+        followlinks_ = False
+    else:
+        followlinks_ = kwargs['followlinks']
+
+    dirlist = []
+    rawlist = os.listdir(pth)
+
+    for F in rawlist:
+        F2 = os.path.join(pth,F)
+        if(os.path.isdir(F2)):
+            b = (followlinks_) or ((not followlinks_) and not(os.path.islink(F2)))
+            if(b):
+                if((F2!=".")&(F2!="..")):
+                    dirlist.append(F2)
+        elif(os.path.isfile(F2)):
+            flst.append(F2)
+
+    #Recurse through directories
+    if(recurse_):
+        for D in dirlist:
+            lst = flist(D,**kwargs)
+            for L in lst:
+                flst.append(L)
+
+    #Postprocess:
+    #Filter out all extensions except the selected ext list
+    if(filterexts_):
+        flst = filterexts(flst,exts)
+
+    #Normalize filename path according to os
+    if(normpath_):
+        flst2 = list(flst)
+        for I in range(0,len(flst2)):
+            flst[I] = os.path.normpath(flst2[I])
+
+    #If linuxpath, convert all \\ to /
+    #if(linuxpath_):
+    #    flst2 = list(flst)
+    #    for I in range(0,len(flst2)):
+    #        flst[I] = linuxpath(flst2[I])
+    
+    return flst
+
+
+def filterexts(flst,exts):
+    """
+    Filters by extensions in a list of files
+    flst = def filterexts(flst,exts):
+    """
+    flst2 = []
+    if(isinstance(exts,str)):
+        exts = list([exts])
+    for F in flst:
+        b = False
+        for ext in exts:
+            if(ext[0]!='.'):
+                ext = '.'+ext
+            F2 = os.path.splitext(F)
+            if(len(F2)>=2):
+                ex = F2[1]
+                if(len(ex)>0):            
+                    if(ex[0]!='.'):
+                        ex = '.'+ex
+                    if(ex==ext):
+                        b = True
+        if(b):
+            flst2.append(F)
+              
+    return flst2
+
+#Find a file fname, starting in pth and recursing
+#Used for finding library files to link
+def findfile(fname,pth,**kwargs):
+    fullfname = ""
+    flst = flist(pth,recurse=True)
+    for F in flst:
+        F2 = os.path.split(F)[1]
+        if(F2 == fname):
+            fullfname = F
+    
+    return fullfname
+
+def replaceext(fname,ext):
+    fname2 = ""
+    if(len(ext)>0):
+        if(ext[0]!='.'):
+            ext = '.'+ext
+        fname2 = os.path.splitext(fname)[0]+ext
+    else:
+        fname2 = os.path.splitext(fname)[0]
+    return fname2
+
+def replaceexts(fnamelist,ext):
+    """Takes a list of filenames and returns a list with the extensions replaced by ext """
+    fname2list = []
+    for F in fnamelist:
+        F2 = replaceext(F,ext)
+        fname2list.append(F2)
+    return fname2list
+
+def except_contains(lst1,exc):
+    """
+    Takes a list of file names lst1, and removes filenams that match the
+    list of exceptions exc. Returns a list without the exceptions.
+    """
+    lst2 = []
+    for item in lst1:
+        b = 1
+        for item2 in exc:
+            fsplit = os.path.split(item)
+            fn = fsplit[len(fsplit)-1]
+            if(fn==item2):
+                b = 0
+                break
+        if(b==1):
+            lst2.append(item)
+    return lst2
+
+
+def list_to_sss(lst):
+    """List of strings to space-seperated-string"""
+    lout = ""
+    for I in range(0,len(lst)-1):
+        lout = lout + lst[I] + " "
+    if(len(lst)>0):
+        lout = lout + lst[len(lst)-1]
+    return lout
+
+##########################
+##System Call Procedures##
+##########################
+
+def callproc(cmd, **kwargs):
+    if(not('logfile' in kwargs)):
+        use_lf = False
+    else:
+        logfile = kwargs['logfile']
+        if(logfile!=""):
+            fp = open(kwargs['logfile'],'a+')
+            use_lf = True
+        else:
+            use_lf = False
+        
+    if(not('echo' in kwargs)):
+        echo = True
+    else:
+        echo = kwargs['echo']
+
+    if(echo):
+        print(cmd)
+
+    #encoding/deconding to/from bytes is necessary to use the subprocess command
+    #in python3.7
+    #However, only do this in linux
+    if(sys.platform!='win32'):
+        cmd2 = cmd.encode(encoding='utf-8')
+    else:
+        cmd2 = cmd
+    proc = subprocess.Popen(cmd2,stderr = subprocess.STDOUT, stdout=subprocess.PIPE, shell=True)
+    (out, err) = proc.communicate()
+
+    out = out.decode(encoding='utf-8')
+    
+    if(echo):
+        print(out)
+        #print(err);
+    if(use_lf):
+        fp.writelines(cmd+'\n')
+        fp.writelines(out+'\n')
+
+    if(use_lf):
+        fp.close()
+
+
+#############################################
+## Compiler, Archive, and Linker Functions ##
+#############################################
+
+#MSVC compiler wrapper
+def msvc_compile(compilername, srcfile, **kwargs):
+
+    if(not('include' in kwargs)):
+        include = ''
+    else:
+        include = kwargs['include']
+        if(isinstance(include,list)):
+            include  = list_to_sss(include)
+    
+    if(not('flags' in kwargs)):
+        flags = ''
+    else:
+        flags = kwargs['flags']
+        if(isinstance(flags,list)):
+            flags = list_to_sss(flags)
+
+    if(not('objext' in kwargs)):
+        objext = '.obj'
+    else:
+        objext = kwargs['objext']
+    
+    if(not('srcfileflag' in kwargs)):
+        srcfileflag = '/c'
+    else:
+        srcfileflag = kwargs['srcfileflag']
+
+    if(not('outfileflag' in kwargs)):
+        outfileflag = '/Fo:'
+    else:
+        outfileflag = kwargs['outfileflag']
+    if(not('logfile' in kwargs)):
+        logfile = ""
+    else:
+        logfile = kwargs['logfile']
+
+    outfile = replaceext(srcfile,objext)
+    ln = compilername+" "+flags+" "+" "+srcfileflag+" "+srcfile+" "+outfileflag+'"'+outfile+'"'
+    ln = ln + " " + include
+
+    callproc(ln,echo=True,logfile=logfile)
+
+    return
+
+#MSVC compiler wrapper
+def msvc_compile_list(compiler,srclist,**kwargs):
+    for S in srclist:
+        msvc_compile(compiler,S,**kwargs)
+    return
+
+#gnu-style compiler compile: Should work with gcc, g++, gfortran
+def gs_compile(compiler,srcfile,**kwargs):
+    if(not('include' in kwargs)):
+        include = ''
+    else:
+        include = kwargs['include']
+        if(isinstance(include,list)):
+            include  = list_to_sss(include)
+    
+    if(not('flags' in kwargs)):
+        flags = ''
+    else:
+        flags = kwargs['flags']
+        if(isinstance(flags,list)):
+            flags = list_to_sss(flags)
+
+    if(not('objext' in kwargs)):
+        objext = '.o'
+    else:
+        objext = kwargs['objext']
+
+    if(not('srcfileflag' in kwargs)):
+        srcfileflag = '-c'
+    else:
+        srcfileflag = kwargs['srcfileflag']
+
+    if(not('outfileflag' in kwargs)):
+        outfileflag = '-o'
+    else:
+        outfileflag = kwargs['outfileflag']
+
+    if(not('logfile' in kwargs)):
+        logfile = ""
+    else:
+        logfile = kwargs['logfile']
+
+    if(not('smartcompile' in kwargs)):
+        _smartcompile = True
+    else:
+        _smartcompile = kwargs['smartcompile']
+    
+    #Do I want to make this thing this general?
+
+    # if(not(_smartcompile) or smartcompile(srcfile,objext)):
+    #     outfile = replaceext(srcfile,objext)
+    #     ln = compiler+" "+flags+" " + outfileflag+" "+outfile+" "+srcfileflag+" "+srcfile
+    #     ln = ln + " " + include
+
+    #     callproc(ln,echo=True,logfile=logfile)
+
+    outfile = replaceext(srcfile,objext)
+    ln = compiler+" "+flags+" " + outfileflag+" "+outfile+" "+srcfileflag+" "+srcfile
+    ln = ln + " " + include
+
+    callproc(ln,echo=True,logfile=logfile)
+
+    return
+
+def gs_compile_list(compiler,srclist,**kwargs):
+    for S in srclist:
+        gs_compile(compiler,S,**kwargs)
+    return
+
+def gs_compile_all(compiler,srcdir,srcexts,**kwargs):
+    if(not('recurse' in kwargs)):
+        recurse = True
+    else:
+        recurse = kwargs['recurse']
+
+    srcfils = flist(srcdir,exts=srcexts,recurse=recurse)
+    
+    for S in srcfils:
+        gs_compile(compiler,S,**kwargs)
+
+    return
+
+def gs_link_all(linker,srcpath,target,**kwargs):
+
+    if(not('objext' in kwargs)):
+        objext = '.o'
+    else:
+        objext = kwargs['objext']
+
+    if(not('recurse' in kwargs)):
+        recurse = True
+    else:
+        recurse = kwargs['recurse']
+
+
+    objfils = flist(srcpath,exts=objext,recurse=recurse)
+    oflst = list_to_sss(objfils)
+    
+    gs_link_list(linker,oflst,target,**kwargs)
+    
+    return
+
+def gs_link_list(linker,objlist,target,**kwargs):
+
+    if(not('objext' in kwargs)):
+        objext = '.o'
+    else:
+        objext = kwargs['objext']
+
+    if(not('libdir' in kwargs)):
+        libdir = ''
+    else:
+        libdir = kwargs['libdir']
+
+    if(not('staticlibs' in kwargs)):
+        staticlibs = ''
+    else:
+        staticlibs = kwargs['staticlibs']
+
+    if(not('libflags' in kwargs)):
+        libflags = ''
+    else:
+        libflags = kwargs['libflags']
+
+    if(not('linkerflags' in kwargs)):
+        linkerflags = ''
+    else:
+        linkerflags = kwargs['linkerflags']
+
+    if(not('recurse' in kwargs)):
+        recurse = True
+    else:
+        recurse = kwargs['recurse']
+
+    if(not('logfile' in kwargs)):
+        logfile = ''
+    else:
+        logfile = kwargs['logfile']
+
+    ln = linker+" -o "+target+" "+libdir
+    ln = ln+" "+objlist+" "+staticlibs+" "+libflags+" "+linkerflags
+    
+    callproc(ln,logfile=logfile)
+    return
+
+def msvc_link_list(objlist,target,**kwargs):
+
+    linker = 'link'
+
+    if(not('objext' in kwargs)):
+        objext = '.obj'
+    else:
+        objext = kwargs['objext']
+
+    if(not('libdir' in kwargs)):
+        libdir = ''
+    else:
+        libdir = kwargs['libdir']
+
+    if(not('staticlibs' in kwargs)):
+        staticlibs = ''
+    else:
+        staticlibs = kwargs['staticlibs']
+
+    if(not('libflags' in kwargs)):
+        libflags = ''
+    else:
+        libflags = kwargs['libflags']
+
+    if(not('linkerflags' in kwargs)):
+        linkerflags = ''
+    else:
+        linkerflags = kwargs['linkerflags']
+
+    if(not('recurse' in kwargs)):
+        recurse = True
+    else:
+        recurse = kwargs['recurse']
+
+    if(not('logfile' in kwargs)):
+        logfile = ''
+    else:
+        logfile = kwargs['logfile']
+
+    ln = linker+" "+libdir
+    ln = ln+" "+objlist+" "+staticlibs+" "+linkerflags
+    ln = ln+" /out:"+target+" "+libflags
+    
+    callproc(ln,logfile=logfile)
+
+    return
+
+def ar_all(srcpath,arname,**kwargs):
+    if(not('recurse' in kwargs)):
+        recurse = True
+    else:
+        recurse = kwargs['recurse']
+    if(not('objext' in kwargs)):
+        objext = '.o'
+    else:
+        objext = kwargs['objext']
+    
+    objlist = flist(srcpath,exts=objext,recurse=recurse)
+    ar_list(objlist,arname,**kwargs)
+    
+    return
+
+def msvc_lib_list(objlist,arname,**kwargs):
+    objlist2 = list_to_sss(objlist)
+    
+    ln = "lib "+objlist2+" /out:"+arname
+    callproc(ln)
+
+    return
+
+def ar_list(objlist,arname,**kwargs):
+    objlist2 = list_to_sss(objlist)
+
+    ln = "ar cr "+ arname+" "+objlist2
+    callproc(ln)
+    
+    return
+
+def ar_add_list(objlist,arname,**kwargs):
+    objlist2 = list_to_sss(objlist)
+
+    ln = "ar t "+arname+" "+objlist2
+    callproc(ln)
+    return
+
+#####################################
+## Incremental Compilation Library ##
+#####################################
+
+#silently read lines from a text file if exists
+def readtextlines(fname):
+    txtlns = []
+
+    if(not os.path.isfile(fname)):
+        return txtlns
+
+    try:
+        fp = open(fname,"r")
+    except:
+        return txtlns
+
+    ln = " "
+    while(ln!=""):
+        ln = fp.readline()
+        txtlns.append(ln)
+
+    fp.close()
+
+    return txtlns
+
+def getincludefnfrage(includeline):
+
+    fnfrag = ""
+    I1 = -1
+    I2 = -1
+
+    for I in range(0,len(includeline)):
+        if(I1<0 and (includeline[I]=='<' or includeline[I]=='"')):
+            I1 = I
+        if(I1>=0 and (includeline[I]=='>' or includeline[I]=='"')):
+            I2 = I
+            break
+    if(I1>=0 and I2>=0):
+        fnfrag = includeline[I1+1:I2]
+
+    return fnfrag
+
+#Returns the name of the source file fname (if it exists)
+#and all included filenames
+def getsrcandincludes(fname, incdirs):
+
+    flist = []
+    if(os.path.isfile(fname)):
+        flist.append(fname)
+
+        Ilist = 0
+        while(Ilist<len(flist)):
+            #recurse through files
+            f1 = flist[Ilist]
+            lns = readtextlines(f1)
+            for J in range(0,len(lns)):
+                if(lns[J].find("#include")>=0):
+                    fnfrag = getincludefnfrage(lns[J])
+                    for K in range(0,len(incdirs)):
+                        tfn = os.path.join(incdirs[K],fnfrag)
+                        if(os.path.isfile(tfn)):
+                            flist.append(tfn)
+                            break
+
+            Ilist = Ilist + 1
+
+    return flist
+
+#Returns the name of the object file associated with the source file
+#within the object store folder (if it exists)
+def getobjfile(fname,objstore,objext = ".o"):
+
+    fret = ""
+    f1 = os.path.split(fname)[1]
+    f2 = f1
+    while(os.path.splitext(f2)[1]!=""):
+        f2 = os.path.splitext(f2)[0]
+    objext = objext.strip('.')
+    f3 = os.path.join(objstore,"{}.{}".format(f2,objext))
+    if(os.path.exists(f3)):
+        fret = f3
+
+    return fret
+
+def getsrctimes(fname, incdirs):
+
+    ftimes = []
+    flst = getsrcandincludes(fname, incdirs)
+    for I in range(0,len(flst)):
+        f = flst[I]
+        mt = os.path.getmtime(f)
+        ftimes.append(mt)
+    
+    return ftimes
+
+def getobjtime(fname,objstore,objext=".o"):
+    ret = -1
+    fret = getobjfile(fname,objstore,objext)
+    if(fret!=""):
+        ret = os.path.getmtime(fret)
+
+    return ret
+
+#Decide whether or not to compile source file
+def decidecompile(fname,**kwargs):
+    ret = True
+
+    if(not os.path.isfile(fname)):
+        ret = False
+        return ret
+    
+    ##unpack kwargs
+    if("searchincdirs" in kwargs):
+        incdirs = kwargs["searchincdirs"]
+    else:
+        incdirs = ["./include"]
+    
+    if("objext" in kwargs):
+        objext = kwargs["objext"]
+    else:
+        objext = ".o"
+    if("objstore" in kwargs):
+        objstore = kwargs["objstore"]
+    else:
+        objstore = "./objstore"
+    
+    
+    srclist = getsrcandincludes(fname,incdirs)
+    srctlist = getsrctimes(fname,incdirs)
+    obj = getobjfile(fname,objstore,objext)
+    objt = getobjtime(fname,objstore,objext)
+    
+    if(obj!=""):
+        ret = False
+        for I in range(0,len(srctlist)):
+            if(srctlist[I]>objt):
+                ret = True
+                break
+
+    return ret
+
+def gs_incremental_compile(compiler,srcfile,**kwargs):
+
+    if(not('include' in kwargs)):
+        include = ''
+    else:
+        include = kwargs['include']
+        if(isinstance(include,list)):
+            include  = list_to_sss(include)
+    if(not('flags' in kwargs)):
+        flags = ''
+    else:
+        flags = kwargs['flags']
+        if(isinstance(flags,list)):
+            flags = list_to_sss(flags)
+    if(not('objext' in kwargs)):
+        objext = '.o'
+    else:
+        objext = kwargs['objext']
+    if(not('srcfileflag' in kwargs)):
+        srcfileflag = '-c'
+    else:
+        srcfileflag = kwargs['srcfileflag']
+    if(not('outfileflag' in kwargs)):
+        outfileflag = '-o'
+    else:
+        outfileflag = kwargs['outfileflag']
+
+    if(not('logfile' in kwargs)):
+        logfile = ""
+    else:
+        logfile = kwargs['logfile']
+    if(not('smartcompile' in kwargs)):
+        _smartcompile = True
+    else:
+        _smartcompile = kwargs['smartcompile']
+
+    #incrementalcompile
+    if("searchincdirs" in kwargs):
+        incdirs = kwargs["searchincdirs"]
+    else:
+        incdirs = ["./include"]
+    
+    if("objstore" in kwargs):
+        objstore = kwargs["objstore"]
+    else:
+        objstore = "./objstore"
+    
+    #Do I want to make this thing this general?
+
+    docompile = decidecompile(srcfile,**kwargs)
+
+    if(docompile):
+        f1 = os.path.split(srcfile)[1]
+        f2 = f1
+        while(os.path.splitext(f2)[1]!=""):
+            f2 = os.path.splitext(f2)[0]
+        outfile = os.path.join(objstore,"{}{}".format(f2,objext))
+
+        ln = compiler+" "+flags+" " + outfileflag+" "+outfile+" "+srcfileflag+" "+srcfile
+        ln = ln + " " + include
+
+        callproc(ln,echo=True,logfile=logfile)
+
+    return
+
+def msvc_incremental_compile(compiler,srcfile,**kwargs):
+
+    if(not('include' in kwargs)):
+        include = ''
+    else:
+        include = kwargs['include']
+        if(isinstance(include,list)):
+            include  = list_to_sss(include)
+    if(not('flags' in kwargs)):
+        flags = ''
+    else:
+        flags = kwargs['flags']
+        if(isinstance(flags,list)):
+            flags = list_to_sss(flags)
+    if(not('objext' in kwargs)):
+        objext = '.obj'
+    else:
+        objext = kwargs['objext']
+    if(not('srcfileflag' in kwargs)):
+        srcfileflag = '/c'
+    else:
+        srcfileflag = kwargs['srcfileflag']
+    if(not('outfileflag' in kwargs)):
+        outfileflag = '/Fo'
+    else:
+        outfileflag = kwargs['outfileflag']
+
+    if(not('logfile' in kwargs)):
+        logfile = ""
+    else:
+        logfile = kwargs['logfile']
+
+    #incrementalcompile
+    if("searchincdirs" in kwargs):
+        incdirs = kwargs["searchincdirs"]
+    else:
+        incdirs = ["./include"]
+    
+    if("objstore" in kwargs):
+        objstore = kwargs["objstore"]
+    else:
+        objstore = "./objstore"
+    
+    #Do I want to make this thing this general?
+
+    docompile = decidecompile(srcfile,**kwargs)
+
+    if(docompile):
+        f1 = os.path.split(srcfile)[1]
+        f2 = f1
+        while(os.path.splitext(f2)[1]!=""):
+            f2 = os.path.splitext(f2)[0]
+        outfile = os.path.join(objstore,"{}{}".format(f2,objext))
+        outfile = os.path.normpath(outfile)
+
+        ln = compiler+" "+flags+" "+srcfileflag+" "+srcfile+" "+ outfileflag+'"'+outfile+'"'
+        ln = ln + " " + include
+
+        callproc(ln,echo=True,logfile=logfile)
+
+    return
+
+
+def gs_incremental_compile_list(compiler,srclist,**kwargs):
+
+    for s in srclist:
+        gs_incremental_compile(compiler,s,**kwargs)
+
+    return
+
+def msvc_incremental_compile_list(compiler,srclist,**kwargs):
+
+    for s in srclist:
+        msvc_incremental_compile(compiler,s,**kwargs)
+
+    return
+
+#######################
+## Main Script Tests ##
+#######################
+
+def testtimes(args):
+    if(len(args)>=2):
+        flist = getsrcandincludes(args[1],["./include"])
+        ftlist = getsrctimes(args[1],["./include"])
+        for I in range(0,len(flist)):
+            print("{}\t\t{}".format(flist[I],ftlist[I]))
+        
+        print("associated obj file:")
+        fobj = getobjfile(args[1],"./objstore")
+        ftobj = getobjtime(args[1],"./objstore")
+        if(fobj!=""):
+            print("{}\t\t{}".format(fobj,ftobj))
+        else:
+            print("none found")
+
+        cflag = decidecompile(args[1])
+        print("compile? : {}".format(cflag))
+
+    
+    return
+
+# if(__name__ == "__main__"):
+
+#     args = sys.argv
+#     testtimes(args)
+    
+        
+
+        

build/make.linux64.lib.py

@@ -0,0 +1,58 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+import shutil
+from shutil import copytree
+
+from amsbuildlib4 import *
+
+libname = "amscppsimpledraw.linux64" #static library name to generate
+binname = "tests" #create this executable when compiling main.c or main.cpp
+commondir = "../../linux64" #common directory to pul libraries and includes from
+depdir = "./dependencies/linux64" #local pre-compiled dependency libraries and their includes
+installdir = "../../linux64" #directory to install to when finished
+builddir = "./build_linux64"
+
+doinstall = False   #copies the build_output to the install dir when finished
+cc = "g++" #compiler
+cflags = "-fPIC"
+libraries = "-l{} -lamsmathutil25.linux64".format(libname)
+libdirs = "-L{} -L{}/lib -L{}/lib".format(builddir,commondir,depdir)
+linkerflags = "-static -static-libgcc -Wl,-rpath=."
+srcexts = [".c",".cpp"]
+binsrc = ["main.c","main.cpp"] #ignore these files when compiling the static library
+
+#keyword list to control the compilers/linkers
+kwargs = dict()
+include = "-I./include -I{}/include -I{}/include".format(commondir, depdir)
+kwargs["include"] = include
+kwargs["flags"] = cflags
+kwargs["libdir"] = libdirs
+kwargs["libflags"] = libraries
+kwargs["linkerflags"] = linkerflags
+kwargs["recurse"] = True
+kwargs["objstore"] = "{}/objstore".format(builddir)
+kwargs["searchincdirs"] = "./include"
+
+#Find all source files, except the main project files
+srcfiles = flist('./src',exts = srcexts, recurse=True)
+srcfiles = except_contains(srcfiles,binsrc)
+
+#compile all the source files in the list
+#gs_compile_list(cc,files,**kwargs)
+gs_incremental_compile_list(cc,srcfiles,**kwargs)
+
+#archive all the source files into a static library
+objlist = flist(kwargs['objstore'],exts='.o',recurse=True)
+ar_list(objlist,'{}/lib{}.a'.format(builddir,libname))
+
+if(doinstall):
+    #Push any libraries to the common lib folder
+    shutil.copy(
+        '{}/lib{}.a'.format(builddir,libname),
+        "{}/lib".format(installdir)
+    )
+
+    #Copy include files to the common include folder
+    copytree('./include/',installdir+'/include/',dirs_exist_ok=True)

build/make.linux64.test.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+import shutil
+from shutil import copytree
+
+from amsbuildlib4 import *
+
+libname = "amscppsimpledraw.linux64" #static library name to generate
+binname = "tests" #create this executable when compiling main.c or main.cpp
+commondir = "../../linux64" #common directory to pul libraries and includes from
+depdir = "./dependencies/linux64" #local pre-compiled dependency libraries and their includes
+installdir = "../../linux64" #directory to install to when finished
+builddir = "./build_linux64"
+
+doinstall = False   #copies the build_output to the install dir when finished
+cc = "g++" #compiler
+cflags = "-fPIC"
+libraries = "-l{} -lamsmathutil25.linux64".format(libname)
+libdirs = "-L{} -L{}/lib -L{}/lib".format(builddir,commondir,depdir)
+linkerflags = "-static -static-libgcc -Wl,-rpath=."
+srcexts = [".c",".cpp"]
+binsrc = ["main.c","main.cpp"] #ignore these files when compiling the static library
+
+#keyword list to control the compilers/linkers
+kwargs = dict()
+include = "-I./include -I{}/include -I{}/include".format(commondir, depdir)
+kwargs["include"] = include
+kwargs["flags"] = cflags
+kwargs["libdir"] = libdirs
+kwargs["libflags"] = libraries
+kwargs["linkerflags"] = linkerflags
+kwargs["recurse"] = True
+kwargs["objstore"] = "{}/objstore".format(builddir)
+kwargs["searchincdirs"] = "./include"
+
+#Pull required binary dynamic libraries to the bin folder
+#shutil.copy('{}/lib/libcamsimg3.linux64.so'.format(commondir),builddir);
+#shutil.copy('{}/lib/libamsimg.dll'.format(commondir),builddir);
+#shutil.copy('{}/lib/glew32.dll','./bin_winx64');
+
+#Designate source files for main test program
+fsrc = ['./src/main.cpp']
+fobj = replaceexts(fsrc,'.o')
+
+#Compile test programs
+gs_compile_list(cc,fsrc,**kwargs)
+gs_link_list(cc,list_to_sss(fobj),'{}/{}'.format(builddir,binname),**kwargs)

build/make.mingw64.lib.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+import shutil
+from shutil import copytree
+
+from amsbuildlib4 import *
+
+libname = "amscppsimpledraw.mingw64" #static library name to generate
+binname = "tests" #create this executable when compiling main.c or main.cpp
+commondir = "../../winx64" #common directory to pul libraries and includes from
+depdir = "./dependencies/winx64" #local pre-compiled dependency libraries and their includes
+installdir = "../../winx64" #directory to install to when finished
+builddir = "./build_mingw64"
+
+doinstall = False   #copies the build_output to the install dir when finished
+cc = "x86_64-w64-mingw32-g++" #compiler
+cflags = "-fPIC -O3"
+libraries = "-l{} -lamsmathutil25.mingw64".format(libname)
+libdirs = "-L{} -L{}/lib -L{}/lib".format(builddir,commondir,depdir)
+linkerflags = "-static -static-libgcc -Wl,-rpath=."
+srcexts = [".c",".cpp"]
+binsrc = ["main.c","main.cpp"] #ignore these files when compiling the static library
+
+
+#keyword list to control the compilers/linkers
+kwargs = dict()
+include = "-I./include -I{}/include -I{}/include".format(commondir, depdir)
+kwargs["include"] = include
+kwargs["flags"] = cflags
+kwargs["libdir"] = libdirs
+kwargs["libflags"] = libraries
+kwargs["linkerflags"] = linkerflags
+kwargs["recurse"] = True
+kwargs["objstore"] = "{}/objstore".format(builddir)
+kwargs["searchincdirs"] = "./include"
+
+#Find all source files, except the main project files
+srcfiles = flist('./src',exts = srcexts, recurse=True)
+srcfiles = except_contains(srcfiles,binsrc)
+
+#compile all the source files in the list
+#gs_compile_list(cc,files,**kwargs)
+gs_incremental_compile_list(cc,srcfiles,**kwargs)
+
+#archive all the source files into a static library
+objlist = flist(kwargs['objstore'],exts='.o',recurse=True)
+ar_list(objlist,'{}/lib{}.a'.format(builddir,libname))
+
+if(doinstall):
+    #Push any libraries to the common lib folder
+    shutil.copy(
+        '{}/lib{}.a'.format(builddir,libname),
+        "{}/lib".format(installdir)
+    )
+
+    #Copy include files to the common include folder
+    copytree('./include/',installdir+'/include/',dirs_exist_ok=True)

build/make.mingw64.test.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+import shutil
+from shutil import copytree
+
+from amsbuildlib4 import *
+
+libname = "amscppsimpledraw.mingw64" #static library name to generate
+binname = "tests" #create this executable when compiling main.c or main.cpp
+commondir = "../../winx64" #common directory to pul libraries and includes from
+depdir = "./dependencies/winx64" #local pre-compiled dependency libraries and their includes
+installdir = "../../winx64" #directory to install to when finished
+builddir = "./build_mingw64"
+
+doinstall = False   #copies the build_output to the install dir when finished
+cc = "x86_64-w64-mingw32-g++" #compiler
+cflags = "-fPIC -O3"
+libraries = "-l{} -lamsmathutil25.mingw64".format(libname)
+libdirs = "-L{} -L{}/lib -L{}/lib".format(builddir,commondir,depdir)
+linkerflags = "-static -static-libgcc -Wl,-rpath=."
+srcexts = [".c",".cpp"]
+binsrc = ["main.c","main.cpp"] #ignore these files when compiling the static library
+
+#keyword list to control the compilers/linkers
+kwargs = dict()
+include = "-I./include -I{}/include -I{}/include".format(commondir, depdir)
+kwargs["include"] = include
+kwargs["flags"] = cflags
+kwargs["libdir"] = libdirs
+kwargs["libflags"] = libraries
+kwargs["linkerflags"] = linkerflags
+kwargs["recurse"] = True
+kwargs["objstore"] = "{}/objstore".format(builddir)
+kwargs["searchincdirs"] = "./include"
+
+#Pull required binary dynamic libraries to the bin folder
+#shutil.copy('{}/lib/libcamsimg3.linux64.so'.format(commondir),builddir);
+#shutil.copy('{}/lib/libamsimg.dll'.format(commondir),builddir);
+#shutil.copy('{}/lib/glew32.dll','./bin_winx64');
+
+#Designate source files for main test program
+fsrc = ['./src/main.cpp']
+fobj = replaceexts(fsrc,'.o')
+
+#Compile test programs
+gs_compile_list(cc,fsrc,**kwargs)
+gs_link_list(cc,list_to_sss(fobj),'{}/{}'.format(builddir,binname),**kwargs)

build/make.msvc64.lib.py

@@ -0,0 +1,61 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+import shutil
+from shutil import copytree
+
+from amsbuildlib4 import *
+
+libname = "amscppsimpledraw.msvc64" #static library name to generate
+binname = "tests" #create this executable when compiling main.c or main.cpp
+commondir = "../../winx64" #common directory to pul libraries and includes from
+depdir = "./dependencies/winx64" #local pre-compiled dependency libraries and their includes
+installdir = "../../winx64" #directory to install to when finished
+builddir = "./build_msvc64"
+
+doinstall = False   #copies the build_output to the install dir when finished
+cc = "cl" #compiler
+cflags = "/O2"
+libraries = "lib{}.lib libamsmathutil25.msvc64.lib".format(libname)
+libdirs = "/LIBPATH:{} /LIBPATH:{}/lib /LIBPATH:{}/lib".format(builddir,commondir,depdir)
+linkerflags = "-static -static-libgcc -Wl,-rpath=."
+srcexts = [".c",".cpp"]
+binsrc = ["main.c","main.cpp"] #ignore these files when compiling the static library
+
+
+#keyword list to control the compilers/linkers
+kwargs = dict()
+include = "-I./include -I{}/include -I{}/include".format(commondir, depdir)
+kwargs["include"] = include
+kwargs["flags"] = cflags
+kwargs["libdir"] = libdirs
+kwargs["libflags"] = libraries
+kwargs["linkerflags"] = linkerflags
+kwargs["recurse"] = True
+kwargs["objstore"] = "{}/objstore".format(builddir)
+kwargs["searchincdirs"] = "./include"
+kwargs["objext"] = ".obj"
+
+
+#Find all source files, except the main project files
+srcfiles = flist('./src',exts = srcexts, recurse=True)
+srcfiles = except_contains(srcfiles,binsrc)
+
+#compile all the source files in the list
+#gs_compile_list(cc,files,**kwargs)
+msvc_incremental_compile_list(cc,srcfiles,**kwargs)
+
+#archive all the source files into a static library
+objlist = flist(kwargs['objstore'],exts='.obj',recurse=True)
+msvc_lib_list(objlist,'{}/lib{}.lib'.format(builddir,libname))
+
+if(doinstall):
+    #Push any libraries to the common lib folder
+    shutil.copy(
+        '{}/lib{}.lib'.format(builddir,libname),
+        "{}/lib".format(installdir)
+    )
+
+    #Copy include files to the common include folder
+    copytree('./include/',installdir+'/include/',dirs_exist_ok=True)

build/make.msvc64.test.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+
+import os,sys,math
+import subprocess
+import shutil
+from shutil import copytree
+
+from amsbuildlib4 import *
+
+libname = "amscppsimpledraw.msvc64" #static library name to generate
+binname = "tests.exe" #create this executable when compiling main.c or main.cpp
+commondir = "../../winx64" #common directory to pul libraries and includes from
+depdir = "./dependencies/winx64" #local pre-compiled dependency libraries and their includes
+installdir = "../../winx64" #directory to install to when finished
+builddir = "./build_msvc64"
+
+doinstall = False   #copies the build_output to the install dir when finished
+cc = "cl" #compiler
+cflags = "/O2"
+libraries = "lib{}.lib libamsmathutil25.msvc64.lib".format(libname)
+libdirs = "/LIBPATH:{} /LIBPATH:{}/lib /LIBPATH:{}/lib".format(builddir,commondir,depdir)
+linkerflags = ""
+srcexts = [".c",".cpp"]
+binsrc = ["main.c","main.cpp"] #ignore these files when compiling the static library
+
+#keyword list to control the compilers/linkers
+kwargs = dict()
+include = "-I./include -I{}/include -I{}/include".format(commondir, depdir)
+kwargs["include"] = include
+kwargs["flags"] = cflags
+kwargs["libdir"] = libdirs
+kwargs["libflags"] = libraries
+kwargs["linkerflags"] = linkerflags
+kwargs["recurse"] = True
+kwargs["objstore"] = "{}/objstore".format(builddir)
+kwargs["searchincdirs"] = "./include"
+
+#Pull required binary dynamic libraries to the bin folder
+#shutil.copy('{}/lib/libcamsimg3.linux64.so'.format(commondir),builddir);
+#shutil.copy('{}/lib/libamsimg.dll'.format(commondir),builddir);
+#shutil.copy('{}/lib/glew32.dll','./bin_winx64');
+
+#Designate source files for main test program
+fsrc = ['./src/main.cpp']
+fobj = replaceexts(fsrc,'.obj')
+
+#Compile test programs
+msvc_compile_list(cc,fsrc,**kwargs)
+msvc_link_list(list_to_sss(fobj),'{}/{}'.format(builddir,binname),**kwargs)

dependencies/README_PrecompiledDependencies.txt

@@ -0,0 +1,11 @@
+
+This is a folder containing precompiled dependencies for this project from external libraries.
+
+A list of libraries, their sources and licenses is given below:
+
+LIBRARY LIST:
+
+
+A list of each library's own depenencies is given below:
+
+LIBRARY DEPENDENCY LIST:

include/amscppsimpledraw/amscppsimpledraw.hpp

@@ -0,0 +1,59 @@
+#ifndef __AMSCPPSIMPLEDRAW_HPP__
+#define __AMSCPPSIMPLEDRAW_HPP__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <thread>
+
+#include <amsmathutil25/amsmathutil25.hpp>
+
+
+namespace ams
+{
+namespace simpledraw
+{
+
+static const int simpledraw_success = 1;
+static const int simpledraw_failure = -1;
+
+
+class drawcanvas
+{
+    public:
+    int width;
+    int height;
+    
+    double *data; //size [5,width,height] - {r,g,b,alpha,z}
+
+    drawcanvas();
+    ~drawcanvas();
+    drawcanvas(const drawcanvas &other);
+    drawcanvas(drawcanvas &&other) noexcept;
+    drawcanvas& operator=(const drawcanvas &other);
+    drawcanvas& operator=(drawcanvas &&other) noexcept; 
+
+    int resize(int _width, int _height);
+
+    double& operator[](int64_t ind);
+    const double& operator[](int64_t ind) const;
+    double& operator()(int channel, int ix, int iy);
+    const double& operator()(int channel, int ix, int iy) const;
+    double& at(int channel, int ix, int iy);
+    const double& at(int channel, int ix, int iy) const;
+    
+
+
+
+
+};
+
+void test_drawcanvas1();
+
+};
+};
+
+#include <amscppsimpledraw/amscppsimpledraw_util.hpp>
+
+#endif

include/amscppsimpledraw/amscppsimpledraw_util.hpp

@@ -0,0 +1,15 @@
+#ifndef __AMSCPPSIMPLEDRAW_UTIL_HPP__
+#define __AMSCPPSIMPLEDRAW_UTIL_HPP__
+
+namespace ams
+{
+namespace simpledraw
+{
+
+};
+}; //end namespace ams
+
+#include <amscppsimpledraw/amscppsimpledraw_utilimpl.hpp>
+
+#endif
+

include/amscppsimpledraw/amscppsimpledraw_utilimpl.hpp

@@ -0,0 +1,15 @@
+#ifndef __AMSCPPSIMPLEDRAW_UTILIMPL_HPP__
+#define __AMSCPPSIMPLEDRAW_UTILIMPL_HPP__
+
+namespace ams
+{
+namespace simpledraw
+{
+
+};
+}; //end namespace ams
+
+
+
+#endif
+

make_linux.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python3 
+
+import os,sys,math
+from build.amsbuildlib4 import *
+
+if(len(sys.argv)>=2):
+    if(sys.argv[1]=="clean"):
+        obj_list = flist('./build_linux64',recurse=True,exts=['.o'])
+        for o in obj_list:
+            os.remove('{}'.format(o))
+    exit()
+
+os.system('python3 ./build/make.linux64.lib.py')
+os.system('python3 ./build/make.linux64.test.py')
+
+obj_list = flist('./src',recurse=True,exts=['.o'])
+for o in obj_list:
+    os.remove('{}'.format(o))
+
+os.chdir('./build_linux64')
+callproc('./tests')
+os.chdir('..')

make_mingw.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python3
+#!/usr/bin/python3 
+
+import os,sys,math
+from build.amsbuildlib4 import *
+
+if(len(sys.argv)>=2):
+    if(sys.argv[1]=="clean"):
+        obj_list = flist('./build_mingw64',recurse=True,exts=['.o'])
+        for o in obj_list:
+            os.remove('{}'.format(o))
+    exit()
+
+os.system('python3 ./build/make.mingw64.lib.py')
+os.system('python3 ./build/make.mingw64.test.py')
+
+obj_list = flist('./src',recurse=True,exts=['.o'])
+for o in obj_list:
+    os.remove('{}'.format(o))
+
+if(sys.platform!="win32"):
+    os.chdir('./build_mingw64')
+    callproc('wine ./tests.exe')
+    os.chdir('..')
+else:
+    os.chdir('./build_mingw64')
+    callproc('tests.exe')
+    os.chdir('..')

make_msvc.py

@@ -0,0 +1,23 @@
+#!/usr/bin/python3
+#!/usr/bin/python3 
+
+import os,sys,math
+from build.amsbuildlib4 import *
+
+if(len(sys.argv)>=2):
+    if(sys.argv[1]=="clean"):
+        obj_list = flist('./build_msvc64',recurse=True,exts=['.o'])
+        for o in obj_list:
+            os.remove('{}'.format(o))
+    exit()
+
+os.system('python3 ./build/make.msvc64.lib.py')
+os.system('python3 ./build/make.msvc64.test.py')
+
+obj_list = flist('./src',recurse=True,exts=['.o','.obj'])
+for o in obj_list:
+    os.remove('{}'.format(o))
+
+os.chdir('./build_msvc64')
+callproc('tests.exe')
+os.chdir('..')

pull.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/bash 
+
+scp aschinder@amssolarempire.com:workspace/projects/amscppsimpledraw.tar.gz ../tar xzvf ../amscppsimpledraw.tar.gz ./

src/amscppsimpledraw/amscppsimpledraw_template.cpp

@@ -0,0 +1,9 @@
+#include <amscppsimpledraw/amscppsimpledraw.hpp>
+
+namespace ams
+{
+namespace simpledraw
+{
+
+};
+};

src/amscppsimpledraw/amscppsimpledraw_tests1.cpp

@@ -0,0 +1,17 @@
+#include <amscppsimpledraw/amscppsimpledraw.hpp>
+
+namespace ams
+{
+namespace simpledraw
+{
+
+void test_drawcanvas1()
+{
+    drawcanvas q;
+    q.resize(1000,1000);
+
+    
+};
+
+};
+};

src/amscppsimpledraw/amscppsimpledrwaw_drawcanvas.cpp

@@ -0,0 +1,308 @@
+#include <amscppsimpledraw/amscppsimpledraw.hpp>
+
+namespace ams
+{
+namespace simpledraw
+{
+
+    drawcanvas::drawcanvas()
+    {
+        width = 0;
+        height = 0;
+        data = NULL;
+        return;
+    }
+
+    drawcanvas::~drawcanvas()
+    {
+        width = 0;
+        height = 0;
+        if(data!=NULL) {delete[] data; data=NULL;}
+        return;
+    }
+
+    drawcanvas::drawcanvas(const drawcanvas &other)
+    {
+        width = 0;
+        height = 0;
+        data = NULL;
+        if(this!=&other)
+        {
+            this->resize(other.width,other.height);
+            ::ams::buffer_cast_copy<double,double>(this->data,other.data,width*height*5);
+        }
+
+    }
+
+    drawcanvas::drawcanvas(drawcanvas &&other) noexcept
+    {
+        width = 0;
+        height = 0;
+        data = NULL;
+        if(this!=&other)
+        {
+            this->width = other.width;
+            this->height = other.height;
+            this->data = other.data;
+            other.width = 0;
+            other.height = 0;
+            other.data = NULL;
+        }
+        return;
+    }
+    drawcanvas& drawcanvas::operator=(const drawcanvas &other)
+    {
+        if(this!=&other)
+        {
+            this->resize(other.width,other.height);
+            ::ams::buffer_cast_copy<double,double>(this->data,other.data,width*height*5);
+        }
+        return *this;
+    }
+
+    drawcanvas& drawcanvas::operator=(drawcanvas &&other) noexcept
+    {
+        if(this!=&other)
+        {
+            width = 0;
+            height = 0;
+            if(data != NULL) {delete[] data; data=NULL;}
+
+            this->width = other.width;
+            this->height = other.height;
+            this->data = other.data;
+            
+            other.width = 0;
+            other.height = 0;
+            other.data = NULL;
+        }
+        return *this;
+    }
+
+    void drawcanvas_copy_region_tf(
+        int threadnum,
+        int nthreads,
+        drawcanvas *to,
+        drawcanvas *from,
+        int xoffset,
+        int yoffset      
+    )
+    {
+        int64_t I,I0,I1,N;
+        int Ix,Iy,K;
+        int64_t xmin,xmax,ymin,ymax,dx,dy;
+
+        xmin = xoffset;
+        ymin = yoffset;
+        xmax = ::ams::min(to->width, from->width + xoffset);
+        ymax = ::ams::min(to->height, from->height + yoffset);
+        dx = ((xmax-xmin)<0) ? 0 : xmax-xmin;
+        dy = ((ymax-ymin)<0) ? 0 : ymax-ymin;
+        N = dx*dy;
+
+        I0 = (threadnum)*N;
+        I1 = (threadnum<nthreads-1) ? (threadnum+1)*N : N;
+        for(I=I0;I<I1;I++)
+        {
+            Ix = I0%dx;
+            Iy = I0/dx;
+
+            for(K=0;K<5;K++)
+            {
+                to->at(K,Ix+xoffset,Iy+yoffset) = from->at(K,Ix,Iy);
+            }
+        }
+
+
+    }
+
+    void drawcanvas_copy_region(
+        drawcanvas *to,
+        drawcanvas *from,
+        int xoffset,
+        int yoffset
+    )
+    {
+        int64_t N;
+        int64_t xmin,xmax,ymin,ymax,dx,dy;
+
+        xmin = xoffset;
+        ymin = yoffset;
+        xmax = ::ams::min(to->width, from->width + xoffset);
+        ymax = ::ams::min(to->height, from->height + yoffset);
+        dx = ((xmax-xmin)<0) ? 0 : xmax-xmin;
+        dy = ((ymax-ymin)<0) ? 0 : ymax-ymin;
+        N = dx*dy;
+
+        if(N>=0)
+        {
+            ::ams::threaded_execute(
+                drawcanvas_copy_region_tf,
+                N,
+                to,
+                from,
+                xoffset,
+                yoffset
+            );
+        }
+        return;
+    }
+
+    void drawcanvas_copy_region_tf2(
+        int threadnum,
+        int nthreads,
+        double *to,
+        int to_width,
+        int to_height,
+        double *from,
+        int from_width,
+        int from_height,
+        int xoffset,
+        int yoffset  
+    )
+    {
+        int64_t I,I0,I1,N;
+        int Ix,Iy,K;
+        int64_t xmin,xmax,ymin,ymax,dx,dy;
+
+        xmin = xoffset;
+        ymin = yoffset;
+        xmax = ::ams::min(to_width, from_width + xoffset);
+        ymax = ::ams::min(to_height, from_height + yoffset);
+        dx = ((xmax-xmin)<0) ? 0 : xmax-xmin;
+        dy = ((ymax-ymin)<0) ? 0 : ymax-ymin;
+        N = dx*dy;
+
+        I0 = (threadnum)*N;
+        I1 = (threadnum<nthreads-1) ? (threadnum+1)*N : N;
+        for(I=I0;I<I1;I++)
+        {
+            Ix = I0%dx;
+            Iy = I0/dx;
+
+            for(K=0;K<5;K++)
+            {
+                to[K + 5*(Ix + xoffset) + 5*to_width*(Iy+yoffset)] = 
+                from[K + 5*(Ix) + 5*from_width*(Iy)];
+            }
+        }
+
+
+    }
+
+    void drawcanvas_copy_region(
+        double *to,
+        int to_width,
+        int to_height,
+        double *from,
+        int from_width,
+        int from_height,
+        int xoffset,
+        int yoffset
+    )
+    {
+        int64_t N;
+        int64_t xmin,xmax,ymin,ymax,dx,dy;
+
+        xmin = xoffset;
+        ymin = yoffset;
+        xmax = ::ams::min(to_width, from_width + xoffset);
+        ymax = ::ams::min(to_height, from_height + yoffset);
+        dx = ((xmax-xmin)<0) ? 0 : xmax-xmin;
+        dy = ((ymax-ymin)<0) ? 0 : ymax-ymin;
+        N = dx*dy;
+
+        if(N>=0)
+        {
+            ::ams::threaded_execute(
+                drawcanvas_copy_region_tf2,
+                N,
+                to,
+                to_width,
+                to_height,
+                from,
+                from_width,
+                from_height,
+                xoffset,
+                yoffset
+            );
+        }
+        return;
+    }
+
+
+
+
+    int drawcanvas::resize(int _width, int _height)
+    {
+        int ret = simpledraw_success;
+        double *newdata = NULL;
+
+        _width = (_width<0)? 0 : _width;
+        _height = (_height<0)? 0 : _height;
+
+        if(_width*_height==0)
+        {
+            if(data!=NULL) {delete[] data; data=NULL;}
+            width = 0;
+            height = 0;
+            ret = simpledraw_success;
+            return ret;
+        }
+
+        newdata = new(std::nothrow) double[_width*_height*5];
+        if(newdata=NULL)
+        {
+            printf("drawcanvas::resize : Error, newdata could not be allocated.\n");
+            ret = simpledraw_failure;
+            return ret;
+        }
+
+        ::ams::buffer_set<double>(newdata,width*height,0);
+
+        drawcanvas_copy_region(
+            this->data,
+            this->width,
+            this->height,
+            newdata,
+            _width,
+            _height,
+            0,0
+        );
+
+    
+        return ret;
+    }
+
+    double& drawcanvas::operator[](int64_t ind)
+    {
+        return data[ind];
+    }
+
+    const double& drawcanvas::operator[](int64_t ind) const
+    {
+        return data[ind];
+    }
+
+    double& drawcanvas::operator()(int channel, int ix, int iy)
+    {
+        return data[channel + 5*ix + 5*width*iy];
+    }
+
+    const double& drawcanvas::operator()(int channel, int ix, int iy) const
+    {
+        return data[channel + 5*ix + 5*width*iy];
+    }
+
+    double& drawcanvas::at(int channel, int ix, int iy)
+    {
+        return data[channel + 5*ix + 5*width*iy];
+    }
+
+    const double& drawcanvas::at(int channel, int ix, int iy) const
+    {
+        return data[channel + 5*ix + 5*width*iy];
+    }
+
+};
+};

src/main.cpp

@@ -0,0 +1,11 @@
+#include <amscppsimpledraw/amscppsimpledraw.hpp>
+
+int main(int argc, char* argv[])
+{
+    int ret = 0;
+    printf("ams c++ project template tests.\n");
+
+    ams::simpledraw::test_drawcanvas1();
+
+    return ret;
+}