From 2970091f72152ce34f48fe6a1d9f98ec796e2ea7 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Wed, 8 Apr 2015 14:24:29 -0400 Subject: [PATCH 01/33] DEV: Moved mathops.py and test_img_proc from skxray to vttools After review of the arithmetic tools with Eric, we decided that tools whos sole purpose is to wrap existing tools into more user friendly VisTrails modules should be located in VTTools, thereby leaving skxray to exclusively contain new analysis tools and functions, while continuing to increase the usefullness and usability of VisTrails for analysis of NSLS-II data. The file mathops.py has been moved to vttools/to_wrap and renamed as image_proc.py. The file test_img_proc.py has been copied from skxray/tests/ to vttools/tests/. --- vttools/tests/test_img_proc.py | 363 +++++++++++++++++++++++++++++++++ vttools/to_wrap/image_proc.py | 349 +++++++++++++++++++++++++++++++ 2 files changed, 712 insertions(+) create mode 100644 vttools/tests/test_img_proc.py create mode 100644 vttools/to_wrap/image_proc.py diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py new file mode 100644 index 0000000..43e5b10 --- /dev/null +++ b/vttools/tests/test_img_proc.py @@ -0,0 +1,363 @@ +# Module for the BNL image processing project +# Developed at the NSLS-II, Brookhaven National Laboratory +# Developed by Gabriel Iltis, Sept. 2014 +""" +This module contains test functions for the file-IO functions +for reading and writing data sets using the netCDF file format. + +The files read and written using this function are assumed to +conform to the format specified for x-ray computed microtomorgraphy +data collected at Argonne National Laboratory, Sector 13, GSECars. +""" + +import numpy as np +import six +from skxray.img_proc import mathops +from numpy.testing import assert_equal, assert_raises + + +#Test Data +test_array_1 = np.zeros((30,30,30), dtype=int) +test_array_1[0:15, 0:15, 0:15] = 1 +test_array_2 = np.zeros((50, 70, 50), dtype=int) +test_array_2[25:50, 25:50, 25:50] = 87 +test_array_3 = np.zeros((10,10,10), dtype=float) +test_array_4 = np.zeros((100,100,100), dtype=float) +test_array_5 = np.zeros((100,100), dtype=int) +test_array_5[25:75, 25:75] = 254 + +test_1D_array_1 = np.zeros((100), dtype=int) +test_1D_array_2 = np.zeros((10), dtype=int) +test_1D_array_3 = np.zeros((100), dtype=float) + +test_constant_int = 5 +test_constant_flt = 2.0 +test_constant_bool = True + +def test_arithmetic_basic(): + """ + Test function for the image processing function: arithmetic_basic + + """ + test_array_1 = np.zeros((30,30,30), dtype=int) + test_array_1[0:15, 0:15, 0:15] = 1 + test_array_2 = np.zeros((30, 30, 30), dtype=int) + test_array_2[15:29, 15:29, 15:29] = 87 + test_array_3 = np.ones((30,30,30), dtype=float) + test_array_3[10:20, 10:20, 10:20] = 87.4 + test_array_4 = np.zeros((30,30), dtype=int) + test_array_4[24:29, 24:29] = 254 + + test_1D_array_1 = np.zeros((100), dtype=int) + test_1D_array_1[0:30]=50 + test_1D_array_2 = np.zeros((50), dtype=int) + test_1D_array_2[20:49]=10 + test_1D_array_3 = np.ones((100), dtype=float) + + test_constant_int = 5 + test_constant_flt = 2.0 + + #Int array and int constant + add_check = test_array_1 + test_constant_int + sub_check = np.subtract(test_array_1, test_constant_int) + mult_check = np.multiply(test_array_1, test_constant_int) + div_check = np.divide(test_array_1, test_constant_int) + + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'multiplication'), + mult_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'division'), + div_check) + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_1, + test_array_1, + 'division') + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_1, + 0, + 'division') + + #Int array and int array + add_check = test_array_1 + test_array_2 + sub_check = np.subtract(test_array_1, test_array_2) + mult_check = np.multiply(test_array_1, test_array_2) + div_check = np.divide(test_array_1, test_array_2) + + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_2, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_2, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_2, + 'multiplication'), + mult_check) + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_2, + test_array_1, + 'division') + + #Float array and float constant + add_check = test_array_3 + test_constant_flt + sub_check = np.subtract(test_array_3, test_constant_flt) + mult_check = np.multiply(test_array_3, test_constant_flt) + div_check = np.divide(test_array_3, test_constant_flt) + + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'multiplication'), + mult_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'division'), + div_check) + #Float array and float array + add_check = test_array_3 + test_array_3 + sub_check = np.subtract(test_array_3, test_array_3) + mult_check = np.multiply(test_array_3, test_array_3) + div_check = np.divide(test_array_3, test_array_3) + + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'multiplication'), + mult_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'division'), + div_check) + #Mixed dtypes: Int array and float array + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_1.astype(float), + 'addition').dtype, + float) + #Float array and int constant + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_int, + 'addition').dtype, + float) + #Int array and float constant + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_flt, + 'addition').dtype, + float) + #Mismatched array sizes + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_1, + test_array_3, + 'addition') + + +def test_arithmetic_custom(): + """ + Test function for mathops.arithmetic_custom, a function that allows the + inclusion of up to 8 inputs (arrays or constants) and application of a + custom expression, to simplify image arithmetic including 2 or more + objects or parameters. + """ + #TEST DATA + test_array_1 = np.zeros((90,90,90), dtype=int) + test_array_1[10:19, 10:19, 10:19] = 1 + test_array_2 = np.zeros((90,90,90), dtype=int) + test_array_2[20:29, 20:29, 20:29] = 2 + test_array_3 = np.zeros((90,90,90), dtype=int) + test_array_3[30:39, 30:39, 30:39] = 3 + test_array_4 = np.zeros((90,90,90), dtype=int) + test_array_4[40:49, 40:49, 40:49] = 4 + test_array_5 = np.zeros((90,90,90), dtype=int) + test_array_5[50:59, 50:59, 50:59] = 5 + test_array_6 = np.zeros((90,90,90), dtype=int) + test_array_6[60:69, 60:69, 60:69] = 6 + test_array_7 = np.zeros((90,90,90), dtype=int) + test_array_7[70:79, 70:79, 70:79] = 7 + test_array_8 = np.zeros((90,90,90), dtype=int) + test_array_8[80:89, 80:89, 80:89] = 8 + + #Array manipulation + #-int only + result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + + test_array_5 + test_array_6 + test_array_7 + test_array_8) + assert_equal(mathops.arithmetic_custom('A+B+C+D+E+F+G+H', + test_array_1, + test_array_2, + test_array_3, + test_array_4, + test_array_5, + test_array_6, + test_array_7, + test_array_8), + result) + #-float only + result = ((test_array_1.astype(float) + 3.5) + + (test_array_3.astype(float) / 2.0) - + test_array_4.astype(float) + ) + assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + test_array_1.astype(float), + 3.5, + test_array_3.astype(float), + 2.0, + test_array_4.astype(float)), + result) + #-mixed int and float + result = ((test_array_1 + 3.5) + + (test_array_3.astype(float) / 2) - + test_array_4 + ) + assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + test_array_1, + 3.5, + test_array_3.astype(float), + 2, + test_array_4.astype(float)), + result) + assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + test_array_1, + 3.5, + test_array_3.astype(float), + 2, + test_array_4.astype(float)).dtype, + float) + + + +def test_logic(): + """ + Test function for mathops.logic_basic, a function that allows for + logical operations to be performed on one or two arrays or constants + depending on the type of operation. + For example: + logical not only takes one object, and returns the inverse, while the + other operations provide a comparison of two objects). + """ + #TEST DATA + test_array_1 = np.zeros((90,90,90), dtype=int) + test_array_1[0:39, 0:39, 0:39] = 1 + test_array_2 = np.zeros((90,90,90), dtype=int) + test_array_2[20:79, 20:79, 20:79] = 2 + test_array_3 = np.zeros((90,90,90), dtype=int) + test_array_3[40:89, 40:89, 40:89] = 3 + + #and + assert_equal(mathops.logic_basic('and', test_array_1, test_array_1), + test_array_1) + + test_result = mathops.logic_basic('and', test_array_1, test_array_2) + assert_equal(test_result[20:39, 20:39, 20:39], True) + assert_equal(test_result.sum(), ((39-20)**3)) + + test_result = mathops.logic_basic('and', test_array_1, test_array_3) + assert_equal(test_result, False) + + #or + assert_equal(mathops.logic_basic('or', test_array_1, test_array_1), + test_array_1) + + assert_equal(mathops.logic_basic('or', + test_array_1, + test_array_2).sum(), + (test_array_1.sum() + + test_array_2.sum() / + 2 - + np.logical_and(test_array_1, + test_array_2).sum() + ) + ) + test_result = mathops.logic_basic('or', test_array_1, test_array_3) + assert_equal(test_result.sum(), + (test_array_1.sum() + + test_array_3.sum() / + test_array_3.max() + ) + ) + + #not + assert_equal(mathops.logic_basic('not', test_array_1).sum(), + (90**3-test_array_1.sum())) + assert_equal(mathops.logic_basic('not', test_array_3).sum(), + (90**3-(test_array_3.sum()/test_array_3.max()))) + + #xor + assert_equal(mathops.logic_basic('xor', test_array_1, test_array_1), + np.zeros((90,90,90), dtype=int)) + assert_equal(mathops.logic_basic('xor', + test_array_1, + test_array_2).sum(), + ((test_array_1.sum() + + test_array_2.sum() / 2) - + (2 * np.logical_and(test_array_1, + test_array_2).sum() + ) + ) + ) + + #nand + assert_equal(mathops.logic_basic('nand', test_array_1, test_array_1), + np.logical_not(test_array_1)) + test_result = mathops.logic_basic('nand', test_array_1, test_array_2) + assert_equal(test_result[20:39, 20:39, 20:39], False) + + #nor + assert_equal(mathops.logic_basic('nor', test_array_1, test_array_1), + np.logical_not(test_array_1)) + assert_equal(mathops.logic_basic('nor', + test_array_1, + test_array_2).sum(), + (np.ones((90,90,90), dtype=int).sum() - + (np.logical_or(test_array_1, + test_array_2).sum() + ) + ) + ) + + #subtract + assert_equal(mathops.logic_basic('subtract', test_array_1, test_array_1), + False) + test_result = mathops.logic_basic('subtract', test_array_1, test_array_2) + assert_equal(test_result[20:39, 20:39, 20:39], False) + assert_equal(test_result.sum(), + (test_array_1.sum() - + np.logical_and(test_array_1, + test_array_2).sum() + ) + ) + test_result = mathops.logic_basic('subtract', test_array_1, test_array_3) + assert_equal(test_result, test_array_1) + + +if __name__ == '__main__': + import nose + nose.runmodule(argv=['-s', '--with-doctest'], exit=False) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py new file mode 100644 index 0000000..e975076 --- /dev/null +++ b/vttools/to_wrap/image_proc.py @@ -0,0 +1,349 @@ +# Module for the BNL image processing project +# Developed at the NSLS-II, Brookhaven National Laboratory +# Developed by Gabriel Iltis, Oct. 2013 +""" +This module is designed to facilitate image arithmetic and logical operations +on image data sets. +""" + +import numpy as np +import parser + + +def arithmetic_basic(input_1, + input_2, + operation): + """ + This function enables basic arithmetic for image processing and data + analysis. The function is capable of applying the basic arithmetic + operations (addition, subtraction, multiplication and division) to two + data set arrays, two constants, or an array and a constant. + + Parameters + ---------- + input_1 : {ndarray, int, float} + Specifies the first input data set, or constant, to be offset or + manipulated + + input_2 : {ndarray, int, float} + Specifies the second data set, or constant, to be offset or manipulated + + operation : string + addition: the addition of EITHER two images or volume data sets, + OR an image/data set and a value. This function is typically + used for offset purposes, or basic recombination of several isolated + materials or phases into a single segmented volume. + subtraction: enables the subtraction of EITHER one image or volume data + set from another, OR reduction of all values in an image/data set + by a set value. This function is typically used for offset + purposes, or basic isolation of objects or materials/phases in a + data set. + multiplication: + + division: + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or constant to the designated variable + + Example + ------- + result = mathops.arithmetic_basic(img_1, img_2, 'addition') + """ + operation_dict = {'addition' : np.add, + 'subtraction' : np.subtract, + 'multiplication' : np.multiply, + 'division' : np.divide + } + if operation == 'division': + if type(input_2) is np.ndarray: + if 0 in input_2: + raise ValueError("This division operation will result in " + "division by zero values. Please reevaluate " + "denominator (input_2).") + else: + if float(input_2) == 0: + raise ValueError("This division operation will result in " + "division by a zero value. Please " + "reevaluate the denominator constant" + " (input_2).") + + output = operation_dict[operation](input_1, input_2) + return output + + +def arithmetic_custom(expression, + A, + B, + C=None, + D=None, + E=None, + F=None, + G=None, + H=None): + """ + This function enables more complex arithmetic to be carried out on 2 or + more (current limit is 8) arrays or constants. The arithmetic expression + is defined by the user, as a string, and after assignment of inputs A + through H the string is parsed into the appropriate python expression + and executed. Note that inputs C through H are optional and need only be + defined when desired or required. + + + Parameters + ---------- + expression : string + Note that the syntax of the mathematical expression must conform to + python syntax, + eg.: + using * for multiplication instead of x + using ** for exponents instead of ^ + + Arithmetic operators: + + : addition (adds values on either side of the operator + - : subtraction (subtracts values on either side of the operator + * : multiplication (multiplies values on either side of the + operator + / : division (divides the left operand (numerator) by the right + hand operand (denominator)) + % : modulus (divides the left operand (numerator) by the right + hand operand (denominator) and returns the remainder) + ** : exponent (left operand (base) is raised to the power of the + right operand (exponent)) + // : floor division (divides the left operand (numerator) by the + right hand operand (denominator), but returns the quotient + with any digits after the decimal point removed, + e.g. 9.0/2.0 = 4.0) + + Logical operations are also included and available so long as the: + > : greater than + < : less than + == : exactly equals + != : not equal + >= : greater than or equal + <= : less than or equal + + Additional operators: + = : assignment operator (assigns values from right side to those + on the left side) + += : Adds the right operand to the left operand and sets the + total equal to the left operand, + e.g.: + b+=a is equivalent to b=a+b + -= : Subtracts the right operand from the left operand and sets + the total equal to the left operand, + e.g.: + b -= a is equivalent to b = b - a + *= : multiplies the right operand to the left operand and sets the + total equal to the left operand, + e.g.: + b *= a is equivalent to b = b * a + /= : divides the right operand into the left operand and sets the + total equal to the left operand, + e.g.: + b /= a is equivalent to b = b / a + %= : divides the right operand into the left operand and sets the + remainder equal to the left operand, + e.g.: + b %= a is equivalent to b =b % a + **= : raises the left operand to the power of the right operand + and sets the total equal to the left operand, + e.g.: + b **= a is equivalent to b = b ** a + //= : divides the right operand into the left operand and + then removes any values after the decimal point. The total + is then set equal to the left operand, + e.g.: + b //= a is equivalent to b = b // a + + In the event that bitwise operations are required the operators &, + |, ^, ~ may also be used, though I'm struggling to come up with a + scenario where this will be used. + + Order of operations and parenthesis are taken into account when + evaluating the expression. + + A : {ndarray, int, float} + Data set or constant to be offset or manipulated + + B : {ndarray, int, float} + Data set or constant to be offset or manipulated + + C : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + D : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + E : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + F : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + G : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + H : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or value to the designated variable + + Example + ------- + result = mathops.arithmetic_custom('(A+C)/(B+D)', img_1, img_2, 2, 4) + """ + output = eval(parser.expr(expression).compile()) + return output + + +def logic_basic(operation, + src_data1, + src_data2=None): + """ + This function enables the computation of the basic logical operations + oft used in image processing of two image or volume data sets. This + function can be used for data comparison, material isolation, + noise removal, or mask application/generation. + + Parameters + ---------- + operation : str + options include: + 'and' -- 2 inputs + 'or' -- 2 inputs + 'not' -- 1 input + 'xor' -- 2 inputs + 'nand' -- 2 inputs + 'subtract' -- 2 inputs + + src_data1 : {ndarray, int, float, list, tuple} + Specifies the first reference + + src_data2 : {ndarray, int, float, list, tuple} + Specifies the second reference + + Returns + ------- + output : {ndarray, bool} + Returns the result of the logical operation, which can be an array, + or a simple boolean result. + + Example + ------- + result = mathops.logic_basic('and', img_1, img_2) + """ + logic_dict = {'and' : np.logical_and, + 'or' : np.logical_or, + 'not' : np.logical_not, + 'xor' : np.logical_xor, + 'nand' : logical_NAND, + 'nor' : logical_NOR, + 'subtract' : logical_SUB + } + output = logic_dict[operation](src_data1, + src_data2) + return output + + +def logical_NAND(src_data1, + src_data2): + """ + This function enables the computation of the LOGICAL_NAND of two image or + volume data sets. This function enables easy isolation of all data points + NOT INCLUDED IN BOTH SOURCE DATA SETS. This function can be used for data + comparison, material isolation, noise removal, or mask + application/generation. + + Parameters + ---------- + src_data1 : ndarray + Specifies the first reference data + + src_data2 : ndarray + Specifies the second reference data + + Returns + ------- + output : ndarray + Returns the resulting array to the designated variable + + Example + ------- + result = mathops.logical_NAND('img_1', 'img_2') + """ + output = np.logical_not(np.logical_and(src_data1, + src_data2)) + return output + + +def logical_NOR(src_data1, + src_data2): + """ + This function enables the computation of the LOGICAL_NOR of two image or + volume data sets. This function enables easy isolation of all data points + NOT INCLUDED IN EITHER OF THE SOURCE DATA SETS. This function can be used + for data comparison, material isolation, noise removal, or mask + application/generation. + + Parameters + ---------- + src_data1 : ndarray + Specifies the first reference data + + src_data2 : ndarray + Specifies the second reference data + + Returns + ------- + output : ndarray + Returns the resulting array to the designated variable + + Example + ------- + result = mathops.logical_NOR('img_1', 'img_2') + """ + output = np.logical_not(np.logical_or(src_data1, + src_data2)) + return output + + +def logical_SUB(src_data1, + src_data2): + """ + This function enables LOGICAL SUBTRACTION of one binary image or volume data + set from another. This function can be used to remove phase information, + interface boundaries, or noise, present in two data sets, without having to + worry about mislabeling of pixels which would result from arithmetic + subtraction. This function will evaluate as true for all "true" voxels + present ONLY in Source Dataset 1. This function can be used for data + cleanup, or boundary/interface analysis. + + Parameters + ---------- + src_data1 : ndarray + Specifies the first reference data + + src_data2 : ndarray + Specifies the second reference data + + Returns + ------- + output : ndarray + Returns the resulting array to the designated variable + + Example + ------- + result = mathops.logical_SUB('img_1', 'img_2') + """ + temp = np.logical_not(np.logical_and(src_data1, + src_data2)) + output = np.logical_and(src_data1, + temp) + return output From af219e22d211ded8a0a957cbdc3f798324ec57ca Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Thu, 9 Apr 2015 14:56:14 -0400 Subject: [PATCH 02/33] DEV: Reduced the included funcs to only arith funcs specific to VisTrails As per review and comment from Eric, the arithmetic functions designed explicitly to ease image processing and data analysis in VisTrails have been moved to the VTTools repo. This commit removes the addl analysis funcs, which will remain in skxray (logical_nand, logical_nor, logical_sub). The remaining functions (arithmetic_basic, arithmetic_custom, and logic_basic) remain. All additional math functions are directly imported from either mathops or numpy. And names for mathops functions have been corrected to mimic style established in Numpy. --- vttools/to_wrap/image_proc.py | 123 +++++----------------------------- 1 file changed, 16 insertions(+), 107 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index e975076..eeae89e 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -8,6 +8,9 @@ import numpy as np import parser +from skxray.img_proc.mathops import (logical_sub, logical_nand, logical_nor) +from numpy import (logical_xor, logical_and, logical_or, logical_not, add, + subtract, multiply, divide) def arithmetic_basic(input_1, @@ -52,10 +55,10 @@ def arithmetic_basic(input_1, ------- result = mathops.arithmetic_basic(img_1, img_2, 'addition') """ - operation_dict = {'addition' : np.add, - 'subtraction' : np.subtract, - 'multiplication' : np.multiply, - 'division' : np.divide + operation_dict = {'addition' : add, + 'subtraction' : subtract, + 'multiplication' : multiply, + 'division' : divide } if operation == 'division': if type(input_2) is np.ndarray: @@ -239,111 +242,17 @@ def logic_basic(operation, ------- result = mathops.logic_basic('and', img_1, img_2) """ - logic_dict = {'and' : np.logical_and, - 'or' : np.logical_or, - 'not' : np.logical_not, - 'xor' : np.logical_xor, - 'nand' : logical_NAND, - 'nor' : logical_NOR, - 'subtract' : logical_SUB + logic_dict = {'and' : logical_and, + 'or' : logical_or, + 'not' : logical_not, + 'xor' : logical_xor, + 'nand' : logical_nand, + 'nor' : logical_nor, + 'subtract' : logical_sub } output = logic_dict[operation](src_data1, src_data2) return output - -def logical_NAND(src_data1, - src_data2): - """ - This function enables the computation of the LOGICAL_NAND of two image or - volume data sets. This function enables easy isolation of all data points - NOT INCLUDED IN BOTH SOURCE DATA SETS. This function can be used for data - comparison, material isolation, noise removal, or mask - application/generation. - - Parameters - ---------- - src_data1 : ndarray - Specifies the first reference data - - src_data2 : ndarray - Specifies the second reference data - - Returns - ------- - output : ndarray - Returns the resulting array to the designated variable - - Example - ------- - result = mathops.logical_NAND('img_1', 'img_2') - """ - output = np.logical_not(np.logical_and(src_data1, - src_data2)) - return output - - -def logical_NOR(src_data1, - src_data2): - """ - This function enables the computation of the LOGICAL_NOR of two image or - volume data sets. This function enables easy isolation of all data points - NOT INCLUDED IN EITHER OF THE SOURCE DATA SETS. This function can be used - for data comparison, material isolation, noise removal, or mask - application/generation. - - Parameters - ---------- - src_data1 : ndarray - Specifies the first reference data - - src_data2 : ndarray - Specifies the second reference data - - Returns - ------- - output : ndarray - Returns the resulting array to the designated variable - - Example - ------- - result = mathops.logical_NOR('img_1', 'img_2') - """ - output = np.logical_not(np.logical_or(src_data1, - src_data2)) - return output - - -def logical_SUB(src_data1, - src_data2): - """ - This function enables LOGICAL SUBTRACTION of one binary image or volume data - set from another. This function can be used to remove phase information, - interface boundaries, or noise, present in two data sets, without having to - worry about mislabeling of pixels which would result from arithmetic - subtraction. This function will evaluate as true for all "true" voxels - present ONLY in Source Dataset 1. This function can be used for data - cleanup, or boundary/interface analysis. - - Parameters - ---------- - src_data1 : ndarray - Specifies the first reference data - - src_data2 : ndarray - Specifies the second reference data - - Returns - ------- - output : ndarray - Returns the resulting array to the designated variable - - Example - ------- - result = mathops.logical_SUB('img_1', 'img_2') - """ - temp = np.logical_not(np.logical_and(src_data1, - src_data2)) - output = np.logical_and(src_data1, - temp) - return output +__all__ = (add, subtract, multiply, divide, logical_and, logical_or, + logical_nor, logical_xor, logical_not, logical_sub, logical_nand) \ No newline at end of file From 221fb0d407b87f21a1612be4c63bc6f1941df437 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Fri, 10 Apr 2015 15:30:16 -0400 Subject: [PATCH 03/33] DEV: Added __init__ to vttools tests folder. Can now access tests --- vttools/tests/__init__.py | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 vttools/tests/__init__.py diff --git a/vttools/tests/__init__.py b/vttools/tests/__init__.py new file mode 100644 index 0000000..0ee4e8c --- /dev/null +++ b/vttools/tests/__init__.py @@ -0,0 +1,36 @@ +# ###################################################################### +# Copyright (c) 2014, Brookhaven Science Associates, Brookhaven # +# National Laboratory. All rights reserved. # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions # +# are met: # +# # +# * Redistributions of source code must retain the above copyright # +# notice, this list of conditions and the following disclaimer. # +# # +# * 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. # +# # +# * Neither the name of the Brookhaven Science Associates, Brookhaven # +# National Laboratory 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 OTHERWISE) ARISING # +# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # +# POSSIBILITY OF SUCH DAMAGE. # +######################################################################## +import logging +logger = logging.getLogger(__name__) \ No newline at end of file From d8c978ab1e26ff84acf50cd8074463c61218c698 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Fri, 10 Apr 2015 15:32:10 -0400 Subject: [PATCH 04/33] TST: Img arith tool test. Changed tool location and refs to srch vttool Simple term replacement. Replaced all references to mathops by changing import statement to: import vttools.to_wrap.image_proc as img The tests included focus on the vistrails specific functions: arithmetic_basic, logic_basic, and arithmetic_custom --- vttools/tests/test_img_proc.py | 88 +++++++++++++++++----------------- 1 file changed, 44 insertions(+), 44 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 43e5b10..458b4a5 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -12,7 +12,7 @@ import numpy as np import six -from skxray.img_proc import mathops +import vttools.to_wrap.image_proc as img from numpy.testing import assert_equal, assert_raises @@ -63,29 +63,29 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_1, test_constant_int) div_check = np.divide(test_array_1, test_constant_int) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'multiplication'), mult_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'division'), div_check) assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_1, test_array_1, 'division') assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_1, 0, 'division') @@ -96,20 +96,20 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_1, test_array_2) div_check = np.divide(test_array_1, test_array_2) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_2, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_2, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_2, 'multiplication'), mult_check) assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_2, test_array_1, 'division') @@ -120,19 +120,19 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_3, test_constant_flt) div_check = np.divide(test_array_3, test_constant_flt) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'multiplication'), mult_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'division'), div_check) @@ -142,40 +142,40 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_3, test_array_3) div_check = np.divide(test_array_3, test_array_3) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'multiplication'), mult_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'division'), div_check) #Mixed dtypes: Int array and float array - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_1.astype(float), 'addition').dtype, float) #Float array and int constant - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_int, 'addition').dtype, float) #Int array and float constant - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_flt, 'addition').dtype, float) #Mismatched array sizes assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_1, test_array_3, 'addition') @@ -210,7 +210,7 @@ def test_arithmetic_custom(): #-int only result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + test_array_5 + test_array_6 + test_array_7 + test_array_8) - assert_equal(mathops.arithmetic_custom('A+B+C+D+E+F+G+H', + assert_equal(img.arithmetic_custom('A+B+C+D+E+F+G+H', test_array_1, test_array_2, test_array_3, @@ -225,7 +225,7 @@ def test_arithmetic_custom(): (test_array_3.astype(float) / 2.0) - test_array_4.astype(float) ) - assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', test_array_1.astype(float), 3.5, test_array_3.astype(float), @@ -237,14 +237,14 @@ def test_arithmetic_custom(): (test_array_3.astype(float) / 2) - test_array_4 ) - assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', test_array_1, 3.5, test_array_3.astype(float), 2, test_array_4.astype(float)), result) - assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', test_array_1, 3.5, test_array_3.astype(float), @@ -272,21 +272,21 @@ def test_logic(): test_array_3[40:89, 40:89, 40:89] = 3 #and - assert_equal(mathops.logic_basic('and', test_array_1, test_array_1), + assert_equal(img.logic_basic('and', test_array_1, test_array_1), test_array_1) - test_result = mathops.logic_basic('and', test_array_1, test_array_2) + test_result = img.logic_basic('and', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], True) assert_equal(test_result.sum(), ((39-20)**3)) - test_result = mathops.logic_basic('and', test_array_1, test_array_3) + test_result = img.logic_basic('and', test_array_1, test_array_3) assert_equal(test_result, False) #or - assert_equal(mathops.logic_basic('or', test_array_1, test_array_1), + assert_equal(img.logic_basic('or', test_array_1, test_array_1), test_array_1) - assert_equal(mathops.logic_basic('or', + assert_equal(img.logic_basic('or', test_array_1, test_array_2).sum(), (test_array_1.sum() + @@ -296,7 +296,7 @@ def test_logic(): test_array_2).sum() ) ) - test_result = mathops.logic_basic('or', test_array_1, test_array_3) + test_result = img.logic_basic('or', test_array_1, test_array_3) assert_equal(test_result.sum(), (test_array_1.sum() + test_array_3.sum() / @@ -305,15 +305,15 @@ def test_logic(): ) #not - assert_equal(mathops.logic_basic('not', test_array_1).sum(), + assert_equal(img.logic_basic('not', test_array_1).sum(), (90**3-test_array_1.sum())) - assert_equal(mathops.logic_basic('not', test_array_3).sum(), + assert_equal(img.logic_basic('not', test_array_3).sum(), (90**3-(test_array_3.sum()/test_array_3.max()))) #xor - assert_equal(mathops.logic_basic('xor', test_array_1, test_array_1), + assert_equal(img.logic_basic('xor', test_array_1, test_array_1), np.zeros((90,90,90), dtype=int)) - assert_equal(mathops.logic_basic('xor', + assert_equal(img.logic_basic('xor', test_array_1, test_array_2).sum(), ((test_array_1.sum() + @@ -325,15 +325,15 @@ def test_logic(): ) #nand - assert_equal(mathops.logic_basic('nand', test_array_1, test_array_1), + assert_equal(img.logic_basic('nand', test_array_1, test_array_1), np.logical_not(test_array_1)) - test_result = mathops.logic_basic('nand', test_array_1, test_array_2) + test_result = img.logic_basic('nand', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) #nor - assert_equal(mathops.logic_basic('nor', test_array_1, test_array_1), + assert_equal(img.logic_basic('nor', test_array_1, test_array_1), np.logical_not(test_array_1)) - assert_equal(mathops.logic_basic('nor', + assert_equal(img.logic_basic('nor', test_array_1, test_array_2).sum(), (np.ones((90,90,90), dtype=int).sum() - @@ -344,9 +344,9 @@ def test_logic(): ) #subtract - assert_equal(mathops.logic_basic('subtract', test_array_1, test_array_1), + assert_equal(img.logic_basic('subtract', test_array_1, test_array_1), False) - test_result = mathops.logic_basic('subtract', test_array_1, test_array_2) + test_result = img.logic_basic('subtract', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) assert_equal(test_result.sum(), (test_array_1.sum() - @@ -354,7 +354,7 @@ def test_logic(): test_array_2).sum() ) ) - test_result = mathops.logic_basic('subtract', test_array_1, test_array_3) + test_result = img.logic_basic('subtract', test_array_1, test_array_3) assert_equal(test_result, test_array_1) From ff10b4af5bf6bf836ea3b37c7f466078c1dbc3a9 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 01:54:15 -0400 Subject: [PATCH 05/33] DEV: Mod to arith_custom docs. Removed additional operators. Previously the docstring for arithmetic_custom included references to additional operators such as +=, -=, *= etc. which are supposed to simplify expressions like a=a+b, which is the equivalent of a+=b. However, the parsing function does not evaluate these short cuts correctly. If these additional operators become important, then I'll revisit and modify the parsing function, or write a custom one. However, at this time the additional operators are deemed to be unnecessary, since the expressions can still be evaluated without the operators.` --- vttools/to_wrap/image_proc.py | 35 +---------------------------------- 1 file changed, 1 insertion(+), 34 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index eeae89e..3e8189d 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -128,40 +128,7 @@ def arithmetic_custom(expression, >= : greater than or equal <= : less than or equal - Additional operators: - = : assignment operator (assigns values from right side to those - on the left side) - += : Adds the right operand to the left operand and sets the - total equal to the left operand, - e.g.: - b+=a is equivalent to b=a+b - -= : Subtracts the right operand from the left operand and sets - the total equal to the left operand, - e.g.: - b -= a is equivalent to b = b - a - *= : multiplies the right operand to the left operand and sets the - total equal to the left operand, - e.g.: - b *= a is equivalent to b = b * a - /= : divides the right operand into the left operand and sets the - total equal to the left operand, - e.g.: - b /= a is equivalent to b = b / a - %= : divides the right operand into the left operand and sets the - remainder equal to the left operand, - e.g.: - b %= a is equivalent to b =b % a - **= : raises the left operand to the power of the right operand - and sets the total equal to the left operand, - e.g.: - b **= a is equivalent to b = b ** a - //= : divides the right operand into the left operand and - then removes any values after the decimal point. The total - is then set equal to the left operand, - e.g.: - b //= a is equivalent to b = b // a - - In the event that bitwise operations are required the operators &, ++- In the event that bitwise operations are required the operators &, |, ^, ~ may also be used, though I'm struggling to come up with a scenario where this will be used. From 9be03cee6ec5c139ab33d5942d43960153d4b254 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 02:22:02 -0400 Subject: [PATCH 06/33] DEV: Changed data inputs to x1 and x2. Completed docstrings for funcs. As per Eric's suggestion, inputs specific to data have been renamed in order to conform to typical numpy docstrings, e.g. the arg src_data1 and src_data2 have been changed to x1 and x2. The funcs requiring a string operation to be defined have also been standardized so that the input order starts with the operation or expression followed by the input data. Finally, the docstring for arithmetic_custom was incomplete, and has been flushed out. --- vttools/to_wrap/image_proc.py | 67 +++++++++++++++++++++-------------- 1 file changed, 41 insertions(+), 26 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 3e8189d..88ea25e 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -13,9 +13,9 @@ subtract, multiply, divide) -def arithmetic_basic(input_1, - input_2, - operation): +def arithmetic_basic(operation, + x1, + x2): """ This function enables basic arithmetic for image processing and data analysis. The function is capable of applying the basic arithmetic @@ -24,26 +24,41 @@ def arithmetic_basic(input_1, Parameters ---------- - input_1 : {ndarray, int, float} - Specifies the first input data set, or constant, to be offset or - manipulated - - input_2 : {ndarray, int, float} - Specifies the second data set, or constant, to be offset or manipulated - operation : string - addition: the addition of EITHER two images or volume data sets, + addition: + The addition of EITHER two images or volume data sets, OR an image/data set and a value. This function is typically - used for offset purposes, or basic recombination of several isolated - materials or phases into a single segmented volume. - subtraction: enables the subtraction of EITHER one image or volume data + used for offset purposes, or basic recombination of several + isolated materials or phases into a single segmented volume. + subtraction: + Enables the subtraction of EITHER one image or volume data set from another, OR reduction of all values in an image/data set by a set value. This function is typically used for offset purposes, or basic isolation of objects or materials/phases in a data set. multiplication: + Enables the multiplication of input 1 (x1) by input 2 (x2). The + inputs can be of any valid numpy data type (e.g. an image or + volume data a fixed, constant, value). This function is typically + used for offset purposes (rescaling), or for assigning values in + the generation of a labelfield identifying objects or + materials/phases in a data set. division: + Enables the division of input 1 (x1, numerator) by input 2 (x2, + denominator). The inputs can be of any valid numpy data type + (e.g. an image or volume data a fixed, constant, value). Basic + tests are included in the division function which test for, + and ensure that division by zero does not occur. This function is + typically used for offset purposes (rescaling, normalization). + + x1 : {ndarray, int, float} + Specifies the first input data set, or constant, to be offset or + manipulated + + x2 : {ndarray, int, float} + Specifies the second data set, or constant, to be offset or manipulated + Returns @@ -61,19 +76,19 @@ def arithmetic_basic(input_1, 'division' : divide } if operation == 'division': - if type(input_2) is np.ndarray: - if 0 in input_2: + if type(x2) is np.ndarray: + if 0 in x2: raise ValueError("This division operation will result in " "division by zero values. Please reevaluate " - "denominator (input_2).") + "denominator (x2).") else: - if float(input_2) == 0: + if float(x2) == 0: raise ValueError("This division operation will result in " "division by a zero value. Please " "reevaluate the denominator constant" - " (input_2).") + " (x2).") - output = operation_dict[operation](input_1, input_2) + output = operation_dict[operation](x1, x2) return output @@ -174,8 +189,8 @@ def arithmetic_custom(expression, def logic_basic(operation, - src_data1, - src_data2=None): + x1, + x2=None): """ This function enables the computation of the basic logical operations oft used in image processing of two image or volume data sets. This @@ -193,10 +208,10 @@ def logic_basic(operation, 'nand' -- 2 inputs 'subtract' -- 2 inputs - src_data1 : {ndarray, int, float, list, tuple} + x1 : {ndarray, int, float, list, tuple} Specifies the first reference - src_data2 : {ndarray, int, float, list, tuple} + x2 : {ndarray, int, float, list, tuple} Specifies the second reference Returns @@ -217,8 +232,8 @@ def logic_basic(operation, 'nor' : logical_nor, 'subtract' : logical_sub } - output = logic_dict[operation](src_data1, - src_data2) + output = logic_dict[operation](x1, + x2) return output __all__ = (add, subtract, multiply, divide, logical_and, logical_or, From 4cf2f9f8aca50b5f378ea00374b175c7861b669e Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 02:34:20 -0400 Subject: [PATCH 07/33] DEV: Renamed functions so they're simpler and more straight forward. As discussed with Eric, we decided to shorten, simplify and make the function names more explicit about their functionality. So, logic_basic has been renamed to logic, arithmetic_basic has been renamed arithmetic, and arithmetic_custom has been changed to arithmetic_expression. In Vistrails these tools are exprected to be nested in the tool tree under an "Image Arithmetic" heading, included in the "Image Processing" tool set/kit. --- vttools/to_wrap/image_proc.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 88ea25e..596c2fa 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -13,9 +13,9 @@ subtract, multiply, divide) -def arithmetic_basic(operation, - x1, - x2): +def arithmetic(operation, + x1, + x2): """ This function enables basic arithmetic for image processing and data analysis. The function is capable of applying the basic arithmetic @@ -92,15 +92,15 @@ def arithmetic_basic(operation, return output -def arithmetic_custom(expression, - A, - B, - C=None, - D=None, - E=None, - F=None, - G=None, - H=None): +def arithmetic_expression(expression, + A, + B, + C=None, + D=None, + E=None, + F=None, + G=None, + H=None): """ This function enables more complex arithmetic to be carried out on 2 or more (current limit is 8) arrays or constants. The arithmetic expression @@ -188,9 +188,9 @@ def arithmetic_custom(expression, return output -def logic_basic(operation, - x1, - x2=None): +def logic(operation, + x1, + x2=None): """ This function enables the computation of the basic logical operations oft used in image processing of two image or volume data sets. This From 5b2e3a27d75f61e67c93243552743a4ad8f83eee Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 09:46:55 -0400 Subject: [PATCH 08/33] DEV: Transferred test funcs for arith tools for VT from skxray. --- vttools/to_wrap/image_proc.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 596c2fa..c1043d0 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -8,9 +8,7 @@ import numpy as np import parser -from skxray.img_proc.mathops import (logical_sub, logical_nand, logical_nor) -from numpy import (logical_xor, logical_and, logical_or, logical_not, add, - subtract, multiply, divide) +from skxray.img_proc.mathops import * def arithmetic(operation, @@ -236,5 +234,4 @@ def logic(operation, x2) return output -__all__ = (add, subtract, multiply, divide, logical_and, logical_or, - logical_nor, logical_xor, logical_not, logical_sub, logical_nand) \ No newline at end of file +__all__ = ["arithmetic", "logic", "arithmetic_custom"] From adf036f8b796c5136ff97f06243916f547320be2 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 14:17:29 -0400 Subject: [PATCH 09/33] DEV: Updated functions in image_proc.py after transfer from skxray --- vttools/to_wrap/image_proc.py | 454 ++++++++++++++++------------------ 1 file changed, 217 insertions(+), 237 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index c1043d0..0ecf75f 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -1,237 +1,217 @@ -# Module for the BNL image processing project -# Developed at the NSLS-II, Brookhaven National Laboratory -# Developed by Gabriel Iltis, Oct. 2013 -""" -This module is designed to facilitate image arithmetic and logical operations -on image data sets. -""" - -import numpy as np -import parser -from skxray.img_proc.mathops import * - - -def arithmetic(operation, - x1, - x2): - """ - This function enables basic arithmetic for image processing and data - analysis. The function is capable of applying the basic arithmetic - operations (addition, subtraction, multiplication and division) to two - data set arrays, two constants, or an array and a constant. - - Parameters - ---------- - operation : string - addition: - The addition of EITHER two images or volume data sets, - OR an image/data set and a value. This function is typically - used for offset purposes, or basic recombination of several - isolated materials or phases into a single segmented volume. - subtraction: - Enables the subtraction of EITHER one image or volume data - set from another, OR reduction of all values in an image/data set - by a set value. This function is typically used for offset - purposes, or basic isolation of objects or materials/phases in a - data set. - multiplication: - Enables the multiplication of input 1 (x1) by input 2 (x2). The - inputs can be of any valid numpy data type (e.g. an image or - volume data a fixed, constant, value). This function is typically - used for offset purposes (rescaling), or for assigning values in - the generation of a labelfield identifying objects or - materials/phases in a data set. - - division: - Enables the division of input 1 (x1, numerator) by input 2 (x2, - denominator). The inputs can be of any valid numpy data type - (e.g. an image or volume data a fixed, constant, value). Basic - tests are included in the division function which test for, - and ensure that division by zero does not occur. This function is - typically used for offset purposes (rescaling, normalization). - - x1 : {ndarray, int, float} - Specifies the first input data set, or constant, to be offset or - manipulated - - x2 : {ndarray, int, float} - Specifies the second data set, or constant, to be offset or manipulated - - - - Returns - ------- - output : {ndarray, int, float} - Returns the resulting array or constant to the designated variable - - Example - ------- - result = mathops.arithmetic_basic(img_1, img_2, 'addition') - """ - operation_dict = {'addition' : add, - 'subtraction' : subtract, - 'multiplication' : multiply, - 'division' : divide - } - if operation == 'division': - if type(x2) is np.ndarray: - if 0 in x2: - raise ValueError("This division operation will result in " - "division by zero values. Please reevaluate " - "denominator (x2).") - else: - if float(x2) == 0: - raise ValueError("This division operation will result in " - "division by a zero value. Please " - "reevaluate the denominator constant" - " (x2).") - - output = operation_dict[operation](x1, x2) - return output - - -def arithmetic_expression(expression, - A, - B, - C=None, - D=None, - E=None, - F=None, - G=None, - H=None): - """ - This function enables more complex arithmetic to be carried out on 2 or - more (current limit is 8) arrays or constants. The arithmetic expression - is defined by the user, as a string, and after assignment of inputs A - through H the string is parsed into the appropriate python expression - and executed. Note that inputs C through H are optional and need only be - defined when desired or required. - - - Parameters - ---------- - expression : string - Note that the syntax of the mathematical expression must conform to - python syntax, - eg.: - using * for multiplication instead of x - using ** for exponents instead of ^ - - Arithmetic operators: - + : addition (adds values on either side of the operator - - : subtraction (subtracts values on either side of the operator - * : multiplication (multiplies values on either side of the - operator - / : division (divides the left operand (numerator) by the right - hand operand (denominator)) - % : modulus (divides the left operand (numerator) by the right - hand operand (denominator) and returns the remainder) - ** : exponent (left operand (base) is raised to the power of the - right operand (exponent)) - // : floor division (divides the left operand (numerator) by the - right hand operand (denominator), but returns the quotient - with any digits after the decimal point removed, - e.g. 9.0/2.0 = 4.0) - - Logical operations are also included and available so long as the: - > : greater than - < : less than - == : exactly equals - != : not equal - >= : greater than or equal - <= : less than or equal - -+- In the event that bitwise operations are required the operators &, - |, ^, ~ may also be used, though I'm struggling to come up with a - scenario where this will be used. - - Order of operations and parenthesis are taken into account when - evaluating the expression. - - A : {ndarray, int, float} - Data set or constant to be offset or manipulated - - B : {ndarray, int, float} - Data set or constant to be offset or manipulated - - C : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - D : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - E : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - F : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - G : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - H : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - - Returns - ------- - output : {ndarray, int, float} - Returns the resulting array or value to the designated variable - - Example - ------- - result = mathops.arithmetic_custom('(A+C)/(B+D)', img_1, img_2, 2, 4) - """ - output = eval(parser.expr(expression).compile()) - return output - - -def logic(operation, - x1, - x2=None): - """ - This function enables the computation of the basic logical operations - oft used in image processing of two image or volume data sets. This - function can be used for data comparison, material isolation, - noise removal, or mask application/generation. - - Parameters - ---------- - operation : str - options include: - 'and' -- 2 inputs - 'or' -- 2 inputs - 'not' -- 1 input - 'xor' -- 2 inputs - 'nand' -- 2 inputs - 'subtract' -- 2 inputs - - x1 : {ndarray, int, float, list, tuple} - Specifies the first reference - - x2 : {ndarray, int, float, list, tuple} - Specifies the second reference - - Returns - ------- - output : {ndarray, bool} - Returns the result of the logical operation, which can be an array, - or a simple boolean result. - - Example - ------- - result = mathops.logic_basic('and', img_1, img_2) - """ - logic_dict = {'and' : logical_and, - 'or' : logical_or, - 'not' : logical_not, - 'xor' : logical_xor, - 'nand' : logical_nand, - 'nor' : logical_nor, - 'subtract' : logical_sub - } - output = logic_dict[operation](x1, - x2) - return output - -__all__ = ["arithmetic", "logic", "arithmetic_custom"] +# Module for the BNL image processing project +# Developed at the NSLS-II, Brookhaven National Laboratory +# Developed by Gabriel Iltis, Oct. 2013 +""" +This module is designed to facilitate image arithmetic and logical operations +on image data sets. +""" + +import numpy as np +import parser +from skxray.img_proc.mathops import * + +__all__ = ["arithmetic", "logic", "arithmetic_expression"] + + +def arithmetic(operation, x1, x2): + """Basic image or object arithmetic for Vistrails image processing + + This function enables basic arithmetic for image processing and data + analysis. The function is capable of applying the basic arithmetic + operations (addition, subtraction, multiplication and division) to two + data set arrays, two constants, or an array and a constant. + + Parameters + ---------- + operation : string + addition: + The addition of EITHER two images or volume data sets, + OR an image/data set and a value. This function is typically + used for offset purposes, or basic recombination of several + isolated materials or phases into a single segmented volume. + subtraction: + Enables the subtraction of EITHER one image or volume data + set from another, OR reduction of all values in an image/data set + by a set value. This function is typically used for offset + purposes, or basic isolation of objects or materials/phases in a + data set. + multiplication: + Enables the multiplication of input 1 (x1) by input 2 (x2). The + inputs can be of any valid numpy data type (e.g. an image or + volume data a fixed, constant, value). This function is typically + used for offset purposes (rescaling), or for assigning values in + the generation of a labelfield identifying objects or + materials/phases in a data set. + + division: + Enables the division of input 1 (x1, numerator) by input 2 (x2, + denominator). The inputs can be of any valid numpy data type + (e.g. an image or volume data a fixed, constant, value). Basic + tests are included in the division function which test for, + and ensure that division by zero does not occur. This function is + typically used for offset purposes (rescaling, normalization). + + x1, x2 : {ndarray, int, float} + Specifies the input data sets, or constants, to be offset or + manipulated + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or constant to the designated variable + + Example + ------- + >>> x1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) + >>> x2 = np.array([[2, 0, 2], [0, 2, 0], [2, 0, 2]]) + >>> arithmetic('addition', x1, x2) + array([[2, 1, 2], + [1, 3, 1], + [2, 1, 2]]) + """ + operation_dict = {'addition' : add, + 'subtraction' : subtract, + 'multiplication' : multiply, + 'division' : divide + } + if operation == 'division': + if type(x2) is np.ndarray: + if 0 in x2: + raise ValueError("This division operation will result in " + "division by zero values. Please reevaluate " + "denominator (x2).") + else: + if float(x2) == 0: + raise ValueError("This division operation will result in " + "division by a zero value. Please " + "reevaluate the denominator constant" + " (x2).") + + return operation_dict[operation](x1, x2) + + +def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, + G=None, H=None): + """Arithmetic tool for VisTrails enabling use of custom expressions + + This function enables more complex arithmetic to be carried out on 2 or + more (current limit is 8) arrays or constants. The arithmetic expression + is defined by the user, as a string, and after assignment of inputs A + through H the string is parsed into the appropriate python expression + and executed. Note that inputs C through H are optional and need only be + defined when desired or required. + + + Parameters + ---------- + expression : string + Note that the syntax of the mathematical expression must conform to + python syntax, + eg.: + using * for multiplication instead of x + using ** for exponents instead of ^ + + Arithmetic operators: + + : addition (adds values on either side of the operator + - : subtraction (subtracts values on either side of the operator + * : multiplication (multiplies values on either side of the + operator + / : division (divides the left operand (numerator) by the right + hand operand (denominator)) + % : modulus (divides the left operand (numerator) by the right + hand operand (denominator) and returns the remainder) + ** : exponent (left operand (base) is raised to the power of the + right operand (exponent)) + // : floor division (divides the left operand (numerator) by the + right hand operand (denominator), but returns the quotient + with any digits after the decimal point removed, + e.g. 9.0/2.0 = 4.0) + + Logical operations are also included and available so long as the: + > : greater than + < : less than + == : exactly equals + != : not equal + >= : greater than or equal + <= : less than or equal + + In the event that bitwise operations are required the operators &, + |, ^, ~ may also be used, though I'm struggling to come up with a + scenario where this will be used. + + Order of operations and parenthesis are taken into account when + evaluating the expression. + + A, B : {ndarray, int, float} + Data set or constant to be offset or manipulated + + C, D, E, F, G, H : {ndarray, int, float}, optional + Optional input ports for data sets or constants to be offset or + manipulated using complex, custom, expressions + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or value to the designated variable + + Example + ------- + >>> A = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) + >>> B = np.array([[2, 0, 2], [0, 2, 0], [2, 0, 2]]) + >>> C = 4 + >>> D = 1.3 + >>> arithmetic_expression('(A+C)/(B+D)', A, B, C, D) + array([[ 1.21212121, 3.84615385, 1.21212121], + [ 3.84615385, 1.51515152, 3.84615385], + [ 1.21212121, 3.84615385, 1.21212121]]) + """ + return eval(parser.expr(expression).compile()) + + +def logic(operation, x1, x2=None): + """VisTrails tool for performing logical operations on image data + + This function enables the computation of the basic logical operations + oft used in image processing of two image or volume data sets. This + function can be used for data comparison, material isolation, + noise removal, or mask application/generation. + + Parameters + ---------- + operation : str + options include: + 'and' -- 2 inputs + 'or' -- 2 inputs + 'not' -- 1 input + 'xor' -- 2 inputs + 'nand' -- 2 inputs + 'subtract' -- 2 inputs + + x1, x2 : {ndarray, int, float, list, tuple} + Specifies the first reference + + Returns + ------- + output : {ndarray, bool} + Returns the result of the logical operation, which can be an array, + or a simple boolean result. + + Example + ------- + >>> x1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) + >>> logic('not', x1) + array([[ True, False, True], + [False, False, False], + [ True, False, True]], dtype=bool) + """ + logic_dict = {'and' : logical_and, + 'or' : logical_or, + 'not' : logical_not, + 'xor' : logical_xor, + 'nand' : logical_nand, + 'nor' : logical_nor, + 'subtract' : logical_sub + } + return logic_dict[operation](x1, x2) From 1b7a073e39cd094c2252138a870bf0050f9be1b1 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 14:18:22 -0400 Subject: [PATCH 10/33] TST: Updated basic arith test function after img_proc name changes --- vttools/tests/test_img_proc.py | 133 ++++++++------------------------- 1 file changed, 33 insertions(+), 100 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 458b4a5..7fc5a99 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -16,24 +16,6 @@ from numpy.testing import assert_equal, assert_raises -#Test Data -test_array_1 = np.zeros((30,30,30), dtype=int) -test_array_1[0:15, 0:15, 0:15] = 1 -test_array_2 = np.zeros((50, 70, 50), dtype=int) -test_array_2[25:50, 25:50, 25:50] = 87 -test_array_3 = np.zeros((10,10,10), dtype=float) -test_array_4 = np.zeros((100,100,100), dtype=float) -test_array_5 = np.zeros((100,100), dtype=int) -test_array_5[25:75, 25:75] = 254 - -test_1D_array_1 = np.zeros((100), dtype=int) -test_1D_array_2 = np.zeros((10), dtype=int) -test_1D_array_3 = np.zeros((100), dtype=float) - -test_constant_int = 5 -test_constant_flt = 2.0 -test_constant_bool = True - def test_arithmetic_basic(): """ Test function for the image processing function: arithmetic_basic @@ -63,56 +45,31 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_1, test_constant_int) div_check = np.divide(test_array_1, test_constant_int) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_1, test_constant_int), add_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'subtraction'), - sub_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'multiplication'), - mult_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'division'), + assert_equal(img.arithmetic(test_array_1, 'subtraction', + test_constant_int), sub_check) + assert_equal(img.arithmetic('multiplication', test_array_1, + test_constant_int), mult_check) + assert_equal(img.arithmetic('division', test_array_1, test_constant_int), div_check) - assert_raises(ValueError, - img.arithmetic_basic, - test_array_1, - test_array_1, - 'division') - assert_raises(ValueError, - img.arithmetic_basic, - test_array_1, - 0, - 'division') + assert_raises(ValueError, img.arithmetic, 'division', test_array_1, + test_array_1) + assert_raises(ValueError, img.arithmetic, 'division', test_array_1, 0) #Int array and int array add_check = test_array_1 + test_array_2 sub_check = np.subtract(test_array_1, test_array_2) mult_check = np.multiply(test_array_1, test_array_2) - div_check = np.divide(test_array_1, test_array_2) - assert_equal(img.arithmetic_basic(test_array_1, - test_array_2, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_1, test_array_2), add_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_array_2, - 'subtraction'), + assert_equal(img.arithmetic('subtraction', test_array_1, test_array_2), sub_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_array_2, - 'multiplication'), + assert_equal(img.arithmetic('multiplication', test_array_1, test_array_2,), mult_check) - assert_raises(ValueError, - img.arithmetic_basic, - test_array_2, - test_array_1, - 'division') + assert_raises(ValueError, img.arithmetic, 'division', test_array_2, + test_array_1) #Float array and float constant add_check = test_array_3 + test_constant_flt @@ -120,65 +77,41 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_3, test_constant_flt) div_check = np.divide(test_array_3, test_constant_flt) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_3, test_constant_flt), add_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'subtraction'), - sub_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'multiplication'), - mult_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'division'), + assert_equal(img.arithmetic('substraction', test_array_3, + test_constant_flt), sub_check) + assert_equal(img.arithmetic('multiplication', test_array_3, + test_constant_flt), mult_check) + assert_equal(img.arithmetic('division', test_array_3, test_constant_flt), div_check) + #Float array and float array add_check = test_array_3 + test_array_3 sub_check = np.subtract(test_array_3, test_array_3) mult_check = np.multiply(test_array_3, test_array_3) div_check = np.divide(test_array_3, test_array_3) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_3, test_array_3), add_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'subtraction'), + assert_equal(img.arithmetic('subtraction', test_array_3, test_array_3,), sub_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'multiplication'), + assert_equal(img.arithmetic('multiplication', test_array_3, test_array_3), mult_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'division'), + assert_equal(img.arithmetic('division', test_array_3, test_array_3), div_check) #Mixed dtypes: Int array and float array - assert_equal(img.arithmetic_basic(test_array_1, - test_array_1.astype(float), - 'addition').dtype, - float) + assert_equal(img.arithmetic('addition', test_array_1, + test_array_1.astype(float)).dtype, float) #Float array and int constant - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_int, - 'addition').dtype, - float) + assert_equal(img.arithmetic('addition', test_array_3, + test_constant_int).dtype, float) #Int array and float constant - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_flt, - 'addition').dtype, - float) + assert_equal(img.arithmetic('addition', test_array_1, + test_constant_flt).dtype, float) #Mismatched array sizes - assert_raises(ValueError, - img.arithmetic_basic, - test_array_1, - test_array_3, - 'addition') + assert_raises(ValueError, img.arithmetic, 'addition', test_array_1, + test_array_3) def test_arithmetic_custom(): From bbed6dce559fb75504dcc41c8013a95fdf544fee Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 14:25:20 -0400 Subject: [PATCH 11/33] TST: Updated test for arith_expression after func name change in vttools --- vttools/tests/test_img_proc.py | 67 ++++++++++++++-------------------- 1 file changed, 27 insertions(+), 40 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 7fc5a99..09228c1 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -116,10 +116,10 @@ def test_arithmetic_basic(): def test_arithmetic_custom(): """ - Test function for mathops.arithmetic_custom, a function that allows the - inclusion of up to 8 inputs (arrays or constants) and application of a - custom expression, to simplify image arithmetic including 2 or more - objects or parameters. + Test function for vttools.to_wrap.image_proc.arithmetic_expression, + a function that allows the inclusion of up to 8 inputs (arrays or + constants) and application of a custom expression, to simplify image + arithmetic including 2 or more objects or parameters. """ #TEST DATA test_array_1 = np.zeros((90,90,90), dtype=int) @@ -143,50 +143,37 @@ def test_arithmetic_custom(): #-int only result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + test_array_5 + test_array_6 + test_array_7 + test_array_8) - assert_equal(img.arithmetic_custom('A+B+C+D+E+F+G+H', - test_array_1, - test_array_2, - test_array_3, - test_array_4, - test_array_5, - test_array_6, - test_array_7, - test_array_8), - result) + + assert_equal(img.arithmetic_expression('A+B+C+D+E+F+G+H', test_array_1, + test_array_2, test_array_3, + test_array_4, test_array_5, + test_array_6, test_array_7, + test_array_8), result) + #-float only result = ((test_array_1.astype(float) + 3.5) + (test_array_3.astype(float) / 2.0) - - test_array_4.astype(float) - ) - assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', - test_array_1.astype(float), - 3.5, - test_array_3.astype(float), - 2.0, - test_array_4.astype(float)), - result) + test_array_4.astype(float)) + + assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', + test_array_1.astype(float), 3.5, + test_array_3.astype(float), 2.0, + test_array_4.astype(float)), result) + #-mixed int and float - result = ((test_array_1 + 3.5) + - (test_array_3.astype(float) / 2) - - test_array_4 - ) - assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', - test_array_1, - 3.5, - test_array_3.astype(float), - 2, - test_array_4.astype(float)), - result) - assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', - test_array_1, - 3.5, - test_array_3.astype(float), - 2, + result = ((test_array_1 + 3.5) + (test_array_3.astype(float) / 2) - + test_array_4) + + assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', test_array_1, 3.5, + test_array_3.astype(float), 2, + test_array_4.astype(float)), result) + + assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', test_array_1, 3.5, + test_array_3.astype(float), 2, test_array_4.astype(float)).dtype, float) - def test_logic(): """ Test function for mathops.logic_basic, a function that allows for From 9822c1fa74d678825d06d506b8991ba5c2471ded Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 15:29:27 -0400 Subject: [PATCH 12/33] DOC: Updated input params docstrings, simplifying them. --- vttools/to_wrap/image_proc.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 0ecf75f..3472dd4 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -51,14 +51,14 @@ def arithmetic(operation, x1, x2): and ensure that division by zero does not occur. This function is typically used for offset purposes (rescaling, normalization). - x1, x2 : {ndarray, int, float} + x1, x2 : array_like Specifies the input data sets, or constants, to be offset or manipulated Returns ------- - output : {ndarray, int, float} + output : array_like Returns the resulting array or constant to the designated variable Example @@ -91,6 +91,7 @@ def arithmetic(operation, x1, x2): return operation_dict[operation](x1, x2) + def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, G=None, H=None): """Arithmetic tool for VisTrails enabling use of custom expressions @@ -189,7 +190,7 @@ def logic(operation, x1, x2=None): 'nand' -- 2 inputs 'subtract' -- 2 inputs - x1, x2 : {ndarray, int, float, list, tuple} + x1, x2 : array_like Specifies the first reference Returns From fcc8d22feddf8543ada985da48bc734d1d9d110b Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 15:30:30 -0400 Subject: [PATCH 13/33] TST: Tested and verified img_proc tst funcs using nose, coverage. --- vttools/tests/test_img_proc.py | 100 +++++++++++++-------------------- 1 file changed, 38 insertions(+), 62 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 09228c1..8080278 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -25,7 +25,7 @@ def test_arithmetic_basic(): test_array_1[0:15, 0:15, 0:15] = 1 test_array_2 = np.zeros((30, 30, 30), dtype=int) test_array_2[15:29, 15:29, 15:29] = 87 - test_array_3 = np.ones((30,30,30), dtype=float) + test_array_3 = np.ones((40,30,30), dtype=float) test_array_3[10:20, 10:20, 10:20] = 87.4 test_array_4 = np.zeros((30,30), dtype=int) test_array_4[24:29, 24:29] = 254 @@ -47,7 +47,7 @@ def test_arithmetic_basic(): assert_equal(img.arithmetic('addition', test_array_1, test_constant_int), add_check) - assert_equal(img.arithmetic(test_array_1, 'subtraction', + assert_equal(img.arithmetic('subtraction', test_array_1, test_constant_int), sub_check) assert_equal(img.arithmetic('multiplication', test_array_1, test_constant_int), mult_check) @@ -79,7 +79,7 @@ def test_arithmetic_basic(): assert_equal(img.arithmetic('addition', test_array_3, test_constant_flt), add_check) - assert_equal(img.arithmetic('substraction', test_array_3, + assert_equal(img.arithmetic('subtraction', test_array_3, test_constant_flt), sub_check) assert_equal(img.arithmetic('multiplication', test_array_3, test_constant_flt), mult_check) @@ -192,89 +192,65 @@ def test_logic(): test_array_3[40:89, 40:89, 40:89] = 3 #and - assert_equal(img.logic_basic('and', test_array_1, test_array_1), - test_array_1) + assert_equal(img.logic('and', test_array_1, test_array_1), test_array_1) - test_result = img.logic_basic('and', test_array_1, test_array_2) + test_result = img.logic('and', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], True) assert_equal(test_result.sum(), ((39-20)**3)) - test_result = img.logic_basic('and', test_array_1, test_array_3) - assert_equal(test_result, False) + assert_equal(img.logic('and', test_array_1, test_array_3), False) #or - assert_equal(img.logic_basic('or', test_array_1, test_array_1), - test_array_1) - - assert_equal(img.logic_basic('or', - test_array_1, - test_array_2).sum(), - (test_array_1.sum() + - test_array_2.sum() / - 2 - - np.logical_and(test_array_1, - test_array_2).sum() - ) - ) - test_result = img.logic_basic('or', test_array_1, test_array_3) - assert_equal(test_result.sum(), - (test_array_1.sum() + - test_array_3.sum() / - test_array_3.max() - ) - ) + assert_equal(img.logic('or', test_array_1, test_array_1), test_array_1) + + assert_equal(img.logic('or', test_array_1, test_array_2).sum(), + (test_array_1.sum() + test_array_2.sum() / 2 - + np.logical_and(test_array_1, test_array_2).sum())) + + test_result = img.logic('or', test_array_1, test_array_3) + assert_equal(test_result.sum(), (test_array_1.sum() + test_array_3.sum() / + test_array_3.max())) #not - assert_equal(img.logic_basic('not', test_array_1).sum(), + assert_equal(img.logic('not', test_array_1).sum(), (90**3-test_array_1.sum())) - assert_equal(img.logic_basic('not', test_array_3).sum(), + + assert_equal(img.logic('not', test_array_3).sum(), (90**3-(test_array_3.sum()/test_array_3.max()))) #xor - assert_equal(img.logic_basic('xor', test_array_1, test_array_1), + assert_equal(img.logic('xor', test_array_1, test_array_1), np.zeros((90,90,90), dtype=int)) - assert_equal(img.logic_basic('xor', - test_array_1, - test_array_2).sum(), - ((test_array_1.sum() + - test_array_2.sum() / 2) - - (2 * np.logical_and(test_array_1, - test_array_2).sum() - ) - ) - ) + + assert_equal(img.logic('xor', test_array_1, test_array_2).sum(), + ((test_array_1.sum() + test_array_2.sum() / 2) - + (2 * np.logical_and(test_array_1, test_array_2).sum()))) #nand - assert_equal(img.logic_basic('nand', test_array_1, test_array_1), + assert_equal(img.logic('nand', test_array_1, test_array_1), np.logical_not(test_array_1)) - test_result = img.logic_basic('nand', test_array_1, test_array_2) + + test_result = img.logic('nand', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) #nor - assert_equal(img.logic_basic('nor', test_array_1, test_array_1), + assert_equal(img.logic('nor', test_array_1, test_array_1), np.logical_not(test_array_1)) - assert_equal(img.logic_basic('nor', - test_array_1, - test_array_2).sum(), + assert_equal(img.logic('nor', test_array_1, test_array_2).sum(), (np.ones((90,90,90), dtype=int).sum() - - (np.logical_or(test_array_1, - test_array_2).sum() - ) - ) - ) + (np.logical_or(test_array_1, test_array_2).sum()))) #subtract - assert_equal(img.logic_basic('subtract', test_array_1, test_array_1), - False) - test_result = img.logic_basic('subtract', test_array_1, test_array_2) + assert_equal(img.logic('subtract', test_array_1, test_array_1), False) + + test_result = img.logic('subtract', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) - assert_equal(test_result.sum(), - (test_array_1.sum() - - np.logical_and(test_array_1, - test_array_2).sum() - ) - ) - test_result = img.logic_basic('subtract', test_array_1, test_array_3) + + assert_equal(test_result.sum(), (test_array_1.sum() - + np.logical_and(test_array_1, + test_array_2).sum())) + + test_result = img.logic('subtract', test_array_1, test_array_3) assert_equal(test_result, test_array_1) From bff1406a635097df662eb24c31dab44a9f64a526 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Wed, 8 Apr 2015 14:24:29 -0400 Subject: [PATCH 14/33] DEV: Moved mathops.py and test_img_proc from skxray to vttools After review of the arithmetic tools with Eric, we decided that tools whos sole purpose is to wrap existing tools into more user friendly VisTrails modules should be located in VTTools, thereby leaving skxray to exclusively contain new analysis tools and functions, while continuing to increase the usefullness and usability of VisTrails for analysis of NSLS-II data. The file mathops.py has been moved to vttools/to_wrap and renamed as image_proc.py. The file test_img_proc.py has been copied from skxray/tests/ to vttools/tests/. --- vttools/tests/test_img_proc.py | 363 +++++++++++++++++++++++++++++++++ vttools/to_wrap/image_proc.py | 349 +++++++++++++++++++++++++++++++ 2 files changed, 712 insertions(+) create mode 100644 vttools/tests/test_img_proc.py create mode 100644 vttools/to_wrap/image_proc.py diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py new file mode 100644 index 0000000..43e5b10 --- /dev/null +++ b/vttools/tests/test_img_proc.py @@ -0,0 +1,363 @@ +# Module for the BNL image processing project +# Developed at the NSLS-II, Brookhaven National Laboratory +# Developed by Gabriel Iltis, Sept. 2014 +""" +This module contains test functions for the file-IO functions +for reading and writing data sets using the netCDF file format. + +The files read and written using this function are assumed to +conform to the format specified for x-ray computed microtomorgraphy +data collected at Argonne National Laboratory, Sector 13, GSECars. +""" + +import numpy as np +import six +from skxray.img_proc import mathops +from numpy.testing import assert_equal, assert_raises + + +#Test Data +test_array_1 = np.zeros((30,30,30), dtype=int) +test_array_1[0:15, 0:15, 0:15] = 1 +test_array_2 = np.zeros((50, 70, 50), dtype=int) +test_array_2[25:50, 25:50, 25:50] = 87 +test_array_3 = np.zeros((10,10,10), dtype=float) +test_array_4 = np.zeros((100,100,100), dtype=float) +test_array_5 = np.zeros((100,100), dtype=int) +test_array_5[25:75, 25:75] = 254 + +test_1D_array_1 = np.zeros((100), dtype=int) +test_1D_array_2 = np.zeros((10), dtype=int) +test_1D_array_3 = np.zeros((100), dtype=float) + +test_constant_int = 5 +test_constant_flt = 2.0 +test_constant_bool = True + +def test_arithmetic_basic(): + """ + Test function for the image processing function: arithmetic_basic + + """ + test_array_1 = np.zeros((30,30,30), dtype=int) + test_array_1[0:15, 0:15, 0:15] = 1 + test_array_2 = np.zeros((30, 30, 30), dtype=int) + test_array_2[15:29, 15:29, 15:29] = 87 + test_array_3 = np.ones((30,30,30), dtype=float) + test_array_3[10:20, 10:20, 10:20] = 87.4 + test_array_4 = np.zeros((30,30), dtype=int) + test_array_4[24:29, 24:29] = 254 + + test_1D_array_1 = np.zeros((100), dtype=int) + test_1D_array_1[0:30]=50 + test_1D_array_2 = np.zeros((50), dtype=int) + test_1D_array_2[20:49]=10 + test_1D_array_3 = np.ones((100), dtype=float) + + test_constant_int = 5 + test_constant_flt = 2.0 + + #Int array and int constant + add_check = test_array_1 + test_constant_int + sub_check = np.subtract(test_array_1, test_constant_int) + mult_check = np.multiply(test_array_1, test_constant_int) + div_check = np.divide(test_array_1, test_constant_int) + + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'multiplication'), + mult_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_int, + 'division'), + div_check) + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_1, + test_array_1, + 'division') + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_1, + 0, + 'division') + + #Int array and int array + add_check = test_array_1 + test_array_2 + sub_check = np.subtract(test_array_1, test_array_2) + mult_check = np.multiply(test_array_1, test_array_2) + div_check = np.divide(test_array_1, test_array_2) + + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_2, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_2, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_2, + 'multiplication'), + mult_check) + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_2, + test_array_1, + 'division') + + #Float array and float constant + add_check = test_array_3 + test_constant_flt + sub_check = np.subtract(test_array_3, test_constant_flt) + mult_check = np.multiply(test_array_3, test_constant_flt) + div_check = np.divide(test_array_3, test_constant_flt) + + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'multiplication'), + mult_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_flt, + 'division'), + div_check) + #Float array and float array + add_check = test_array_3 + test_array_3 + sub_check = np.subtract(test_array_3, test_array_3) + mult_check = np.multiply(test_array_3, test_array_3) + div_check = np.divide(test_array_3, test_array_3) + + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'addition'), + add_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'subtraction'), + sub_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'multiplication'), + mult_check) + assert_equal(mathops.arithmetic_basic(test_array_3, + test_array_3, + 'division'), + div_check) + #Mixed dtypes: Int array and float array + assert_equal(mathops.arithmetic_basic(test_array_1, + test_array_1.astype(float), + 'addition').dtype, + float) + #Float array and int constant + assert_equal(mathops.arithmetic_basic(test_array_3, + test_constant_int, + 'addition').dtype, + float) + #Int array and float constant + assert_equal(mathops.arithmetic_basic(test_array_1, + test_constant_flt, + 'addition').dtype, + float) + #Mismatched array sizes + assert_raises(ValueError, + mathops.arithmetic_basic, + test_array_1, + test_array_3, + 'addition') + + +def test_arithmetic_custom(): + """ + Test function for mathops.arithmetic_custom, a function that allows the + inclusion of up to 8 inputs (arrays or constants) and application of a + custom expression, to simplify image arithmetic including 2 or more + objects or parameters. + """ + #TEST DATA + test_array_1 = np.zeros((90,90,90), dtype=int) + test_array_1[10:19, 10:19, 10:19] = 1 + test_array_2 = np.zeros((90,90,90), dtype=int) + test_array_2[20:29, 20:29, 20:29] = 2 + test_array_3 = np.zeros((90,90,90), dtype=int) + test_array_3[30:39, 30:39, 30:39] = 3 + test_array_4 = np.zeros((90,90,90), dtype=int) + test_array_4[40:49, 40:49, 40:49] = 4 + test_array_5 = np.zeros((90,90,90), dtype=int) + test_array_5[50:59, 50:59, 50:59] = 5 + test_array_6 = np.zeros((90,90,90), dtype=int) + test_array_6[60:69, 60:69, 60:69] = 6 + test_array_7 = np.zeros((90,90,90), dtype=int) + test_array_7[70:79, 70:79, 70:79] = 7 + test_array_8 = np.zeros((90,90,90), dtype=int) + test_array_8[80:89, 80:89, 80:89] = 8 + + #Array manipulation + #-int only + result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + + test_array_5 + test_array_6 + test_array_7 + test_array_8) + assert_equal(mathops.arithmetic_custom('A+B+C+D+E+F+G+H', + test_array_1, + test_array_2, + test_array_3, + test_array_4, + test_array_5, + test_array_6, + test_array_7, + test_array_8), + result) + #-float only + result = ((test_array_1.astype(float) + 3.5) + + (test_array_3.astype(float) / 2.0) - + test_array_4.astype(float) + ) + assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + test_array_1.astype(float), + 3.5, + test_array_3.astype(float), + 2.0, + test_array_4.astype(float)), + result) + #-mixed int and float + result = ((test_array_1 + 3.5) + + (test_array_3.astype(float) / 2) - + test_array_4 + ) + assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + test_array_1, + 3.5, + test_array_3.astype(float), + 2, + test_array_4.astype(float)), + result) + assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + test_array_1, + 3.5, + test_array_3.astype(float), + 2, + test_array_4.astype(float)).dtype, + float) + + + +def test_logic(): + """ + Test function for mathops.logic_basic, a function that allows for + logical operations to be performed on one or two arrays or constants + depending on the type of operation. + For example: + logical not only takes one object, and returns the inverse, while the + other operations provide a comparison of two objects). + """ + #TEST DATA + test_array_1 = np.zeros((90,90,90), dtype=int) + test_array_1[0:39, 0:39, 0:39] = 1 + test_array_2 = np.zeros((90,90,90), dtype=int) + test_array_2[20:79, 20:79, 20:79] = 2 + test_array_3 = np.zeros((90,90,90), dtype=int) + test_array_3[40:89, 40:89, 40:89] = 3 + + #and + assert_equal(mathops.logic_basic('and', test_array_1, test_array_1), + test_array_1) + + test_result = mathops.logic_basic('and', test_array_1, test_array_2) + assert_equal(test_result[20:39, 20:39, 20:39], True) + assert_equal(test_result.sum(), ((39-20)**3)) + + test_result = mathops.logic_basic('and', test_array_1, test_array_3) + assert_equal(test_result, False) + + #or + assert_equal(mathops.logic_basic('or', test_array_1, test_array_1), + test_array_1) + + assert_equal(mathops.logic_basic('or', + test_array_1, + test_array_2).sum(), + (test_array_1.sum() + + test_array_2.sum() / + 2 - + np.logical_and(test_array_1, + test_array_2).sum() + ) + ) + test_result = mathops.logic_basic('or', test_array_1, test_array_3) + assert_equal(test_result.sum(), + (test_array_1.sum() + + test_array_3.sum() / + test_array_3.max() + ) + ) + + #not + assert_equal(mathops.logic_basic('not', test_array_1).sum(), + (90**3-test_array_1.sum())) + assert_equal(mathops.logic_basic('not', test_array_3).sum(), + (90**3-(test_array_3.sum()/test_array_3.max()))) + + #xor + assert_equal(mathops.logic_basic('xor', test_array_1, test_array_1), + np.zeros((90,90,90), dtype=int)) + assert_equal(mathops.logic_basic('xor', + test_array_1, + test_array_2).sum(), + ((test_array_1.sum() + + test_array_2.sum() / 2) - + (2 * np.logical_and(test_array_1, + test_array_2).sum() + ) + ) + ) + + #nand + assert_equal(mathops.logic_basic('nand', test_array_1, test_array_1), + np.logical_not(test_array_1)) + test_result = mathops.logic_basic('nand', test_array_1, test_array_2) + assert_equal(test_result[20:39, 20:39, 20:39], False) + + #nor + assert_equal(mathops.logic_basic('nor', test_array_1, test_array_1), + np.logical_not(test_array_1)) + assert_equal(mathops.logic_basic('nor', + test_array_1, + test_array_2).sum(), + (np.ones((90,90,90), dtype=int).sum() - + (np.logical_or(test_array_1, + test_array_2).sum() + ) + ) + ) + + #subtract + assert_equal(mathops.logic_basic('subtract', test_array_1, test_array_1), + False) + test_result = mathops.logic_basic('subtract', test_array_1, test_array_2) + assert_equal(test_result[20:39, 20:39, 20:39], False) + assert_equal(test_result.sum(), + (test_array_1.sum() - + np.logical_and(test_array_1, + test_array_2).sum() + ) + ) + test_result = mathops.logic_basic('subtract', test_array_1, test_array_3) + assert_equal(test_result, test_array_1) + + +if __name__ == '__main__': + import nose + nose.runmodule(argv=['-s', '--with-doctest'], exit=False) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py new file mode 100644 index 0000000..e975076 --- /dev/null +++ b/vttools/to_wrap/image_proc.py @@ -0,0 +1,349 @@ +# Module for the BNL image processing project +# Developed at the NSLS-II, Brookhaven National Laboratory +# Developed by Gabriel Iltis, Oct. 2013 +""" +This module is designed to facilitate image arithmetic and logical operations +on image data sets. +""" + +import numpy as np +import parser + + +def arithmetic_basic(input_1, + input_2, + operation): + """ + This function enables basic arithmetic for image processing and data + analysis. The function is capable of applying the basic arithmetic + operations (addition, subtraction, multiplication and division) to two + data set arrays, two constants, or an array and a constant. + + Parameters + ---------- + input_1 : {ndarray, int, float} + Specifies the first input data set, or constant, to be offset or + manipulated + + input_2 : {ndarray, int, float} + Specifies the second data set, or constant, to be offset or manipulated + + operation : string + addition: the addition of EITHER two images or volume data sets, + OR an image/data set and a value. This function is typically + used for offset purposes, or basic recombination of several isolated + materials or phases into a single segmented volume. + subtraction: enables the subtraction of EITHER one image or volume data + set from another, OR reduction of all values in an image/data set + by a set value. This function is typically used for offset + purposes, or basic isolation of objects or materials/phases in a + data set. + multiplication: + + division: + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or constant to the designated variable + + Example + ------- + result = mathops.arithmetic_basic(img_1, img_2, 'addition') + """ + operation_dict = {'addition' : np.add, + 'subtraction' : np.subtract, + 'multiplication' : np.multiply, + 'division' : np.divide + } + if operation == 'division': + if type(input_2) is np.ndarray: + if 0 in input_2: + raise ValueError("This division operation will result in " + "division by zero values. Please reevaluate " + "denominator (input_2).") + else: + if float(input_2) == 0: + raise ValueError("This division operation will result in " + "division by a zero value. Please " + "reevaluate the denominator constant" + " (input_2).") + + output = operation_dict[operation](input_1, input_2) + return output + + +def arithmetic_custom(expression, + A, + B, + C=None, + D=None, + E=None, + F=None, + G=None, + H=None): + """ + This function enables more complex arithmetic to be carried out on 2 or + more (current limit is 8) arrays or constants. The arithmetic expression + is defined by the user, as a string, and after assignment of inputs A + through H the string is parsed into the appropriate python expression + and executed. Note that inputs C through H are optional and need only be + defined when desired or required. + + + Parameters + ---------- + expression : string + Note that the syntax of the mathematical expression must conform to + python syntax, + eg.: + using * for multiplication instead of x + using ** for exponents instead of ^ + + Arithmetic operators: + + : addition (adds values on either side of the operator + - : subtraction (subtracts values on either side of the operator + * : multiplication (multiplies values on either side of the + operator + / : division (divides the left operand (numerator) by the right + hand operand (denominator)) + % : modulus (divides the left operand (numerator) by the right + hand operand (denominator) and returns the remainder) + ** : exponent (left operand (base) is raised to the power of the + right operand (exponent)) + // : floor division (divides the left operand (numerator) by the + right hand operand (denominator), but returns the quotient + with any digits after the decimal point removed, + e.g. 9.0/2.0 = 4.0) + + Logical operations are also included and available so long as the: + > : greater than + < : less than + == : exactly equals + != : not equal + >= : greater than or equal + <= : less than or equal + + Additional operators: + = : assignment operator (assigns values from right side to those + on the left side) + += : Adds the right operand to the left operand and sets the + total equal to the left operand, + e.g.: + b+=a is equivalent to b=a+b + -= : Subtracts the right operand from the left operand and sets + the total equal to the left operand, + e.g.: + b -= a is equivalent to b = b - a + *= : multiplies the right operand to the left operand and sets the + total equal to the left operand, + e.g.: + b *= a is equivalent to b = b * a + /= : divides the right operand into the left operand and sets the + total equal to the left operand, + e.g.: + b /= a is equivalent to b = b / a + %= : divides the right operand into the left operand and sets the + remainder equal to the left operand, + e.g.: + b %= a is equivalent to b =b % a + **= : raises the left operand to the power of the right operand + and sets the total equal to the left operand, + e.g.: + b **= a is equivalent to b = b ** a + //= : divides the right operand into the left operand and + then removes any values after the decimal point. The total + is then set equal to the left operand, + e.g.: + b //= a is equivalent to b = b // a + + In the event that bitwise operations are required the operators &, + |, ^, ~ may also be used, though I'm struggling to come up with a + scenario where this will be used. + + Order of operations and parenthesis are taken into account when + evaluating the expression. + + A : {ndarray, int, float} + Data set or constant to be offset or manipulated + + B : {ndarray, int, float} + Data set or constant to be offset or manipulated + + C : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + D : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + E : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + F : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + G : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + H : {ndarray, int, float}, optional + Data set or constant to be offset or manipulated + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or value to the designated variable + + Example + ------- + result = mathops.arithmetic_custom('(A+C)/(B+D)', img_1, img_2, 2, 4) + """ + output = eval(parser.expr(expression).compile()) + return output + + +def logic_basic(operation, + src_data1, + src_data2=None): + """ + This function enables the computation of the basic logical operations + oft used in image processing of two image or volume data sets. This + function can be used for data comparison, material isolation, + noise removal, or mask application/generation. + + Parameters + ---------- + operation : str + options include: + 'and' -- 2 inputs + 'or' -- 2 inputs + 'not' -- 1 input + 'xor' -- 2 inputs + 'nand' -- 2 inputs + 'subtract' -- 2 inputs + + src_data1 : {ndarray, int, float, list, tuple} + Specifies the first reference + + src_data2 : {ndarray, int, float, list, tuple} + Specifies the second reference + + Returns + ------- + output : {ndarray, bool} + Returns the result of the logical operation, which can be an array, + or a simple boolean result. + + Example + ------- + result = mathops.logic_basic('and', img_1, img_2) + """ + logic_dict = {'and' : np.logical_and, + 'or' : np.logical_or, + 'not' : np.logical_not, + 'xor' : np.logical_xor, + 'nand' : logical_NAND, + 'nor' : logical_NOR, + 'subtract' : logical_SUB + } + output = logic_dict[operation](src_data1, + src_data2) + return output + + +def logical_NAND(src_data1, + src_data2): + """ + This function enables the computation of the LOGICAL_NAND of two image or + volume data sets. This function enables easy isolation of all data points + NOT INCLUDED IN BOTH SOURCE DATA SETS. This function can be used for data + comparison, material isolation, noise removal, or mask + application/generation. + + Parameters + ---------- + src_data1 : ndarray + Specifies the first reference data + + src_data2 : ndarray + Specifies the second reference data + + Returns + ------- + output : ndarray + Returns the resulting array to the designated variable + + Example + ------- + result = mathops.logical_NAND('img_1', 'img_2') + """ + output = np.logical_not(np.logical_and(src_data1, + src_data2)) + return output + + +def logical_NOR(src_data1, + src_data2): + """ + This function enables the computation of the LOGICAL_NOR of two image or + volume data sets. This function enables easy isolation of all data points + NOT INCLUDED IN EITHER OF THE SOURCE DATA SETS. This function can be used + for data comparison, material isolation, noise removal, or mask + application/generation. + + Parameters + ---------- + src_data1 : ndarray + Specifies the first reference data + + src_data2 : ndarray + Specifies the second reference data + + Returns + ------- + output : ndarray + Returns the resulting array to the designated variable + + Example + ------- + result = mathops.logical_NOR('img_1', 'img_2') + """ + output = np.logical_not(np.logical_or(src_data1, + src_data2)) + return output + + +def logical_SUB(src_data1, + src_data2): + """ + This function enables LOGICAL SUBTRACTION of one binary image or volume data + set from another. This function can be used to remove phase information, + interface boundaries, or noise, present in two data sets, without having to + worry about mislabeling of pixels which would result from arithmetic + subtraction. This function will evaluate as true for all "true" voxels + present ONLY in Source Dataset 1. This function can be used for data + cleanup, or boundary/interface analysis. + + Parameters + ---------- + src_data1 : ndarray + Specifies the first reference data + + src_data2 : ndarray + Specifies the second reference data + + Returns + ------- + output : ndarray + Returns the resulting array to the designated variable + + Example + ------- + result = mathops.logical_SUB('img_1', 'img_2') + """ + temp = np.logical_not(np.logical_and(src_data1, + src_data2)) + output = np.logical_and(src_data1, + temp) + return output From a69903957b2f5ade4f75f0d421dbf43134c05ad5 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Thu, 9 Apr 2015 14:56:14 -0400 Subject: [PATCH 15/33] DEV: Reduced the included funcs to only arith funcs specific to VisTrails As per review and comment from Eric, the arithmetic functions designed explicitly to ease image processing and data analysis in VisTrails have been moved to the VTTools repo. This commit removes the addl analysis funcs, which will remain in skxray (logical_nand, logical_nor, logical_sub). The remaining functions (arithmetic_basic, arithmetic_custom, and logic_basic) remain. All additional math functions are directly imported from either mathops or numpy. And names for mathops functions have been corrected to mimic style established in Numpy. --- vttools/to_wrap/image_proc.py | 123 +++++----------------------------- 1 file changed, 16 insertions(+), 107 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index e975076..eeae89e 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -8,6 +8,9 @@ import numpy as np import parser +from skxray.img_proc.mathops import (logical_sub, logical_nand, logical_nor) +from numpy import (logical_xor, logical_and, logical_or, logical_not, add, + subtract, multiply, divide) def arithmetic_basic(input_1, @@ -52,10 +55,10 @@ def arithmetic_basic(input_1, ------- result = mathops.arithmetic_basic(img_1, img_2, 'addition') """ - operation_dict = {'addition' : np.add, - 'subtraction' : np.subtract, - 'multiplication' : np.multiply, - 'division' : np.divide + operation_dict = {'addition' : add, + 'subtraction' : subtract, + 'multiplication' : multiply, + 'division' : divide } if operation == 'division': if type(input_2) is np.ndarray: @@ -239,111 +242,17 @@ def logic_basic(operation, ------- result = mathops.logic_basic('and', img_1, img_2) """ - logic_dict = {'and' : np.logical_and, - 'or' : np.logical_or, - 'not' : np.logical_not, - 'xor' : np.logical_xor, - 'nand' : logical_NAND, - 'nor' : logical_NOR, - 'subtract' : logical_SUB + logic_dict = {'and' : logical_and, + 'or' : logical_or, + 'not' : logical_not, + 'xor' : logical_xor, + 'nand' : logical_nand, + 'nor' : logical_nor, + 'subtract' : logical_sub } output = logic_dict[operation](src_data1, src_data2) return output - -def logical_NAND(src_data1, - src_data2): - """ - This function enables the computation of the LOGICAL_NAND of two image or - volume data sets. This function enables easy isolation of all data points - NOT INCLUDED IN BOTH SOURCE DATA SETS. This function can be used for data - comparison, material isolation, noise removal, or mask - application/generation. - - Parameters - ---------- - src_data1 : ndarray - Specifies the first reference data - - src_data2 : ndarray - Specifies the second reference data - - Returns - ------- - output : ndarray - Returns the resulting array to the designated variable - - Example - ------- - result = mathops.logical_NAND('img_1', 'img_2') - """ - output = np.logical_not(np.logical_and(src_data1, - src_data2)) - return output - - -def logical_NOR(src_data1, - src_data2): - """ - This function enables the computation of the LOGICAL_NOR of two image or - volume data sets. This function enables easy isolation of all data points - NOT INCLUDED IN EITHER OF THE SOURCE DATA SETS. This function can be used - for data comparison, material isolation, noise removal, or mask - application/generation. - - Parameters - ---------- - src_data1 : ndarray - Specifies the first reference data - - src_data2 : ndarray - Specifies the second reference data - - Returns - ------- - output : ndarray - Returns the resulting array to the designated variable - - Example - ------- - result = mathops.logical_NOR('img_1', 'img_2') - """ - output = np.logical_not(np.logical_or(src_data1, - src_data2)) - return output - - -def logical_SUB(src_data1, - src_data2): - """ - This function enables LOGICAL SUBTRACTION of one binary image or volume data - set from another. This function can be used to remove phase information, - interface boundaries, or noise, present in two data sets, without having to - worry about mislabeling of pixels which would result from arithmetic - subtraction. This function will evaluate as true for all "true" voxels - present ONLY in Source Dataset 1. This function can be used for data - cleanup, or boundary/interface analysis. - - Parameters - ---------- - src_data1 : ndarray - Specifies the first reference data - - src_data2 : ndarray - Specifies the second reference data - - Returns - ------- - output : ndarray - Returns the resulting array to the designated variable - - Example - ------- - result = mathops.logical_SUB('img_1', 'img_2') - """ - temp = np.logical_not(np.logical_and(src_data1, - src_data2)) - output = np.logical_and(src_data1, - temp) - return output +__all__ = (add, subtract, multiply, divide, logical_and, logical_or, + logical_nor, logical_xor, logical_not, logical_sub, logical_nand) \ No newline at end of file From cf06549631fe2e5da438459ca69454665c71b0de Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Fri, 10 Apr 2015 15:30:16 -0400 Subject: [PATCH 16/33] DEV: Added __init__ to vttools tests folder. Can now access tests --- html/activity.html | 48 +++++ html/arrow-down.gif | Bin 0 -> 73 bytes html/arrow-none.gif | Bin 0 -> 71 bytes html/arrow-up.gif | Bin 0 -> 73 bytes html/authors.html | 40 ++++ html/commits_by_author.dat | 150 ++++++++++++++ html/commits_by_author.plot | 15 ++ html/commits_by_author.png | Bin 0 -> 6659 bytes html/commits_by_year.dat | 1 + html/commits_by_year.plot | 11 + html/commits_by_year.png | Bin 0 -> 2929 bytes html/commits_by_year_month.dat | 4 + html/commits_by_year_month.plot | 14 ++ html/commits_by_year_month.png | Bin 0 -> 2655 bytes html/day_of_week.dat | 7 + html/day_of_week.plot | 11 + html/day_of_week.png | Bin 0 -> 3446 bytes html/domains.dat | 3 + html/domains.plot | 10 + html/domains.png | Bin 0 -> 3224 bytes html/files.html | 30 +++ html/files_by_date.dat | 57 ++++++ html/files_by_date.plot | 15 ++ html/files_by_date.png | Bin 0 -> 2793 bytes html/gitstats.cache | Bin 0 -> 4601 bytes html/gitstats.css | 145 +++++++++++++ html/hour_of_day.dat | 24 +++ html/hour_of_day.plot | 11 + html/hour_of_day.png | Bin 0 -> 3114 bytes html/index.html | 23 +++ html/lines.html | 27 +++ html/lines_of_code.dat | 38 ++++ html/lines_of_code.plot | 14 ++ html/lines_of_code.png | Bin 0 -> 2957 bytes html/lines_of_code_by_author.dat | 150 ++++++++++++++ html/lines_of_code_by_author.plot | 15 ++ html/lines_of_code_by_author.png | Bin 0 -> 6304 bytes html/month_of_year.dat | 12 ++ html/month_of_year.plot | 11 + html/month_of_year.png | Bin 0 -> 2703 bytes html/sortable.js | 324 ++++++++++++++++++++++++++++++ html/tags.html | 22 ++ vttools/tests/__init__.py | 37 +++- 43 files changed, 1268 insertions(+), 1 deletion(-) create mode 100644 html/activity.html create mode 100644 html/arrow-down.gif create mode 100644 html/arrow-none.gif create mode 100644 html/arrow-up.gif create mode 100644 html/authors.html create mode 100644 html/commits_by_author.dat create mode 100644 html/commits_by_author.plot create mode 100644 html/commits_by_author.png create mode 100644 html/commits_by_year.dat create mode 100644 html/commits_by_year.plot create mode 100644 html/commits_by_year.png create mode 100644 html/commits_by_year_month.dat create mode 100644 html/commits_by_year_month.plot create mode 100644 html/commits_by_year_month.png create mode 100644 html/day_of_week.dat create mode 100644 html/day_of_week.plot create mode 100644 html/day_of_week.png create mode 100644 html/domains.dat create mode 100644 html/domains.plot create mode 100644 html/domains.png create mode 100644 html/files.html create mode 100644 html/files_by_date.dat create mode 100644 html/files_by_date.plot create mode 100644 html/files_by_date.png create mode 100644 html/gitstats.cache create mode 100644 html/gitstats.css create mode 100644 html/hour_of_day.dat create mode 100644 html/hour_of_day.plot create mode 100644 html/hour_of_day.png create mode 100644 html/index.html create mode 100644 html/lines.html create mode 100644 html/lines_of_code.dat create mode 100644 html/lines_of_code.plot create mode 100644 html/lines_of_code.png create mode 100644 html/lines_of_code_by_author.dat create mode 100644 html/lines_of_code_by_author.plot create mode 100644 html/lines_of_code_by_author.png create mode 100644 html/month_of_year.dat create mode 100644 html/month_of_year.plot create mode 100644 html/month_of_year.png create mode 100644 html/sortable.js create mode 100644 html/tags.html diff --git a/html/activity.html b/html/activity.html new file mode 100644 index 0000000..20070a5 --- /dev/null +++ b/html/activity.html @@ -0,0 +1,48 @@ + + + + + GitStats - VTTools + + + + + +

Activity

+
+ +
+ +

Weekly activity

+ +

Last 32 weeks

0
0
0
0
0
0
0
0
0
0
0
17
26
19
3
4
17
25
6
5
18
2
0
7
4
0
0
0
0
0
0
0
3231302928272625242322212019181716151413121110987654321
+

Hour of Day

+ + + +
Hour01234567891011121314151617181920212223
Commits100009401651712121015982986154
%0.650.000.000.000.005.882.610.000.653.923.2711.117.847.846.549.805.885.231.315.885.233.929.802.61
Hour of Day +

Day of Week

+ +
DayTotal (%)
Mon24 (15.69%)
Tue30 (19.61%)
Wed25 (16.34%)
Thu27 (17.65%)
Fri31 (20.26%)
Sat9 (5.88%)
Sun7 (4.58%)
Day of Week +

Hour of Week

+ +
Weekday01234567891011121314151617181920212223
Mon11623121322
Tue94151123121
Wed212124211
Thu111345221232
Fri2116636411
Sat12312
Sun2122
+

Month of Year

+ +
MonthCommits (%)
10 (0.00 %)
20 (0.00 %)
30 (0.00 %)
40 (0.00 %)
50 (0.00 %)
60 (0.00 %)
70 (0.00 %)
80 (0.00 %)
965 (42.48 %)
1052 (33.99 %)
1125 (16.34 %)
1211 (7.19 %)
Month of Year +

Commits by year/month

+ +
MonthCommitsLines addedLines removed
2014-121113351
2014-11251024488
2014-1052671129
2014-09652533313
Commits by year/month +

Commits by Year

+ +
YearCommits (% of all)Lines addedLines removed
2014153 (100.00%)4361981
Commits by Year +

Commits by Timezone

+ +
TimezoneCommits
-050036
-0400117
\ No newline at end of file diff --git a/html/arrow-down.gif b/html/arrow-down.gif new file mode 100644 index 0000000000000000000000000000000000000000..997f02f6b53ee1f68236c86178f5e06273b7432e GIT binary patch literal 73 zcmZ?wbhEHb6kyGG6G4(pDc_F49pBV3_t*qXJC?=)1P_h?k<^T Z_nGG6G4(pDc_F49pBV3_t*qXJC?;)1P_p?k<^T X_nGG6G4(pDc_F49pBV3_t*qXJC?=)1P_p?k<^T Z_n + + + + GitStats - VTTools + + + + + +

Authors

+
+ +
+ +

List of Authors

+ +
AuthorCommits (%)+ lines- linesFirst commitLast commitAgeActive days# by commits
Eric Dill62 (40.52%)402312682014-09-092014-12-1192 days, 23:38:08201
Gabriel Iltis41 (26.80%)14049602014-09-182014-10-3041 days, 20:55:14122
Thomas A Caswell27 (17.65%)2721682014-09-092014-12-0789 days, 0:13:52103
Sameera Abeykoon10 (6.54%)45142014-09-292014-10-3031 days, 1:18:3564
licode9 (5.88%)264392014-09-232014-11-1755 days, 0:43:5865
Wei Xu2 (1.31%)332014-12-042014-12-062 days, 8:34:5826
Li Li2 (1.31%)002014-09-232014-11-1452 days, 0:13:5127
+

Cumulated Added Lines of Code per Author

+ +Lines of code per Author +

Commits per Author

+ +Commits per Author +

Author of Month

+ +
MonthAuthorCommits (%)Next top 5Number of authors
2014-12Thomas A Caswell5 (45.45% of 11)Eric Dill, Wei Xu3
2014-11Eric Dill18 (72.00% of 25)licode, Li Li3
2014-10Gabriel Iltis35 (67.31% of 52)Sameera Abeykoon, Thomas A Caswell, Eric Dill, licode5
2014-09Eric Dill38 (58.46% of 65)Thomas A Caswell, Gabriel Iltis, licode, Sameera Abeykoon, Li Li6
+

Author of Year

+ +
YearAuthorCommits (%)Next top 5Number of authors
2014Eric Dill62 (40.52% of 153)Gabriel Iltis, Thomas A Caswell, Sameera Abeykoon, licode, Wei Xu7
+

Commits by Domains

+ +
DomainsTotal (%)
bnl.gov110 (71.90%)
gmail.com31 (20.26%)
ncsu.edu12 (7.84%)
Commits by Domains \ No newline at end of file diff --git a/html/commits_by_author.dat b/html/commits_by_author.dat new file mode 100644 index 0000000..8faeadc --- /dev/null +++ b/html/commits_by_author.dat @@ -0,0 +1,150 @@ +1410295581 1 0 0 0 0 0 0 +1410295903 2 0 0 0 0 0 0 +1410298005 3 0 0 0 0 0 0 +1410307531 3 0 1 0 0 0 0 +1410309908 4 0 1 0 0 0 0 +1410355340 5 0 1 0 0 0 0 +1410461076 6 0 1 0 0 0 0 +1410471462 7 0 1 0 0 0 0 +1410484387 7 0 2 0 0 0 0 +1410539586 8 0 2 0 0 0 0 +1410539655 9 0 2 0 0 0 0 +1410544965 10 0 2 0 0 0 0 +1410547908 11 0 2 0 0 0 0 +1410548603 12 0 2 0 0 0 0 +1410548944 13 0 2 0 0 0 0 +1410549087 13 0 3 0 0 0 0 +1410665665 14 0 3 0 0 0 0 +1411006353 15 0 3 0 0 0 0 +1411006382 16 0 3 0 0 0 0 +1411006470 17 0 3 0 0 0 0 +1411006512 18 0 3 0 0 0 0 +1411006669 19 0 3 0 0 0 0 +1411007173 20 0 3 0 0 0 0 +1411009106 21 0 3 0 0 0 0 +1411051546 21 0 4 0 0 0 0 +1411055425 22 0 4 0 0 0 0 +1411057176 23 0 4 0 0 0 0 +1411057642 23 0 5 0 0 0 0 +1411076409 23 1 5 0 0 0 0 +1411131939 24 1 5 0 0 0 0 +1411136918 24 1 6 0 0 0 0 +1411143263 25 1 6 0 0 0 0 +1411144306 25 1 7 0 0 0 0 +1411145807 26 1 7 0 0 0 0 +1411145842 27 1 7 0 0 0 0 +1411148715 27 2 7 0 0 0 0 +1411221344 28 2 7 0 0 0 0 +1411222174 29 2 7 0 0 0 0 +1411222943 30 2 7 0 0 0 0 +1411225228 31 2 7 0 0 0 0 +1411225419 32 2 7 0 0 0 0 +1411225924 33 2 7 0 0 0 0 +1411264370 34 2 7 0 0 0 0 +1411400322 35 2 7 0 0 0 0 +1411485597 35 2 7 0 1 0 0 +1411485630 35 2 7 0 1 0 1 +1411487201 36 2 7 0 1 0 1 +1411488438 37 2 7 0 1 0 1 +1411602878 37 2 8 0 1 0 1 +1411602919 37 2 9 0 1 0 1 +1411602974 37 2 10 0 1 0 1 +1411603118 37 2 11 0 1 0 1 +1411603285 37 2 12 0 1 0 1 +1411603414 37 2 13 0 1 0 1 +1411611758 37 2 14 0 1 0 1 +1411611862 37 2 15 0 1 0 1 +1411612232 37 2 16 0 1 0 1 +1411612864 37 2 17 0 1 0 1 +1411758852 38 2 17 0 1 0 1 +1411760051 38 3 17 0 1 0 1 +1411760654 38 4 17 0 1 0 1 +1411790072 38 5 17 0 1 0 1 +1412006449 38 5 17 0 2 0 1 +1412011481 38 5 17 1 2 0 1 +1412025015 38 6 17 1 2 0 1 +1412606172 38 6 17 2 2 0 1 +1412798116 38 6 17 3 2 0 1 +1412861933 38 6 17 4 2 0 1 +1412946301 38 6 18 4 2 0 1 +1413386403 38 7 18 4 2 0 1 +1413487584 38 8 18 4 2 0 1 +1413488272 38 9 18 4 2 0 1 +1413489010 38 10 18 4 2 0 1 +1413491521 38 11 18 4 2 0 1 +1413497889 38 12 18 4 2 0 1 +1413505489 38 13 18 4 2 0 1 +1413507110 38 14 18 4 2 0 1 +1413508745 38 15 18 4 2 0 1 +1413510104 38 16 18 4 2 0 1 +1413511413 38 17 18 4 2 0 1 +1413511794 38 18 18 4 2 0 1 +1413570999 38 19 18 4 2 0 1 +1413577844 39 19 18 4 2 0 1 +1413577966 40 19 18 4 2 0 1 +1413578459 40 20 18 4 2 0 1 +1413579084 40 21 18 4 2 0 1 +1413819476 40 21 18 5 2 0 1 +1413819615 40 21 18 6 2 0 1 +1413820012 40 21 18 7 2 0 1 +1413820140 40 21 18 8 2 0 1 +1413820306 40 21 18 9 2 0 1 +1413831813 40 21 19 9 2 0 1 +1413845407 40 22 19 9 2 0 1 +1413848238 40 23 19 9 2 0 1 +1413849155 40 24 19 9 2 0 1 +1413849503 40 25 19 9 2 0 1 +1413855558 40 26 19 9 2 0 1 +1413855728 40 27 19 9 2 0 1 +1413859749 40 28 19 9 2 0 1 +1413860027 40 29 19 9 2 0 1 +1413904720 40 30 19 9 2 0 1 +1413985972 40 31 19 9 2 0 1 +1414002032 40 32 19 9 2 0 1 +1414002161 40 33 19 9 2 0 1 +1414014852 40 34 19 9 2 0 1 +1414015108 40 35 19 9 2 0 1 +1414170215 40 36 19 9 2 0 1 +1414170594 40 37 19 9 2 0 1 +1414171018 40 38 19 9 2 0 1 +1414171440 40 39 19 9 2 0 1 +1414184835 40 40 19 9 2 0 1 +1414525388 40 40 20 9 2 0 1 +1414525888 40 40 21 9 2 0 1 +1414555083 40 40 22 9 2 0 1 +1414694123 40 41 22 9 2 0 1 +1414694596 40 41 22 10 2 0 1 +1414697598 40 41 22 10 3 0 1 +1415040467 40 41 22 10 4 0 1 +1415108847 41 41 22 10 4 0 1 +1415556923 41 41 22 10 6 0 1 +1415558473 41 41 22 10 7 0 1 +1415656887 42 41 22 10 7 0 1 +1415701333 43 41 22 10 7 0 1 +1415701685 44 41 22 10 7 0 1 +1415701963 45 41 22 10 7 0 1 +1415702031 46 41 22 10 7 0 1 +1415702124 47 41 22 10 7 0 1 +1415702345 48 41 22 10 7 0 1 +1415702482 49 41 22 10 7 0 1 +1415702795 50 41 22 10 7 0 1 +1415703024 51 41 22 10 7 0 1 +1415703740 52 41 22 10 7 0 1 +1415703871 53 41 22 10 7 0 1 +1415704040 54 41 22 10 7 0 1 +1415704198 55 41 22 10 7 0 1 +1415722431 56 41 22 10 7 0 1 +1415899718 57 41 22 10 7 0 1 +1415982861 57 41 22 10 7 0 2 +1415989897 58 41 22 10 7 0 2 +1416201507 58 41 22 10 8 0 2 +1416243835 58 41 22 10 9 0 2 +1417724482 58 41 22 10 9 1 2 +1417928180 58 41 22 10 9 2 2 +1417982156 58 41 23 10 9 2 2 +1418000682 58 41 26 10 9 2 2 +1418001563 58 41 27 10 9 2 2 +1418150502 59 41 27 10 9 2 2 +1418159469 60 41 27 10 9 2 2 +1418326503 61 41 27 10 9 2 2 +1418333069 62 41 27 10 9 2 2 diff --git a/html/commits_by_author.plot b/html/commits_by_author.plot new file mode 100644 index 0000000..a73c4c3 --- /dev/null +++ b/html/commits_by_author.plot @@ -0,0 +1,15 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set terminal png transparent size 640,480 +set output 'commits_by_author.png' +set key left top +set yrange [0:] +set xdata time +set timefmt "%s" +set format x "%Y-%m-%d" +set grid y +set ylabel "Commits" +set xtics rotate +set bmargin 6 +plot 'commits_by_author.dat' using 1:2 title "Eric Dill" w lines, 'commits_by_author.dat' using 1:3 title "Gabriel Iltis" w lines, 'commits_by_author.dat' using 1:4 title "Thomas A Caswell" w lines, 'commits_by_author.dat' using 1:5 title "Sameera Abeykoon" w lines, 'commits_by_author.dat' using 1:6 title "licode" w lines, 'commits_by_author.dat' using 1:7 title "Wei Xu" w lines, 'commits_by_author.dat' using 1:8 title "Li Li" w lines diff --git a/html/commits_by_author.png b/html/commits_by_author.png new file mode 100644 index 0000000000000000000000000000000000000000..1ac44c28943e6fc352a98a9fdb1951a99c524c4d GIT binary patch literal 6659 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 literal 0 HcmV?d00001 diff --git a/html/commits_by_year_month.dat b/html/commits_by_year_month.dat new file mode 100644 index 0000000..abea726 --- /dev/null +++ b/html/commits_by_year_month.dat @@ -0,0 +1,4 @@ +2014-09 65 +2014-10 52 +2014-11 25 +2014-12 11 diff --git a/html/commits_by_year_month.plot b/html/commits_by_year_month.plot new file mode 100644 index 0000000..afb6c09 --- /dev/null +++ b/html/commits_by_year_month.plot @@ -0,0 +1,14 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set output 'commits_by_year_month.png' +unset key +set yrange [0:] +set xdata time +set timefmt "%Y-%m" +set format x "%Y-%m" +set xtics rotate +set bmargin 5 +set grid y +set ylabel "Commits" +plot 'commits_by_year_month.dat' using 1:2:(0.5) w boxes fs solid diff --git a/html/commits_by_year_month.png b/html/commits_by_year_month.png new file mode 100644 index 0000000000000000000000000000000000000000..912fbdec3a29f605aeadc8ff38858c293d979426 GIT binary patch literal 2655 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 literal 0 HcmV?d00001 diff --git a/html/files.html b/html/files.html new file mode 100644 index 0000000..e481395 --- /dev/null +++ b/html/files.html @@ -0,0 +1,30 @@ + + + + + GitStats - VTTools + + + + + +

Files

+
+ +
+
+
Total files
27
Total lines
3380
Average file size
4870.04 bytes
+ +

File count by date

+ +Files by Date +

Extensions

+ +
ExtensionFiles (%)Lines (%)Lines/file
3 (11.11%)100 (2.96%)33
md1 (3.70%)1 (0.03%)1
py19 (70.37%)3098 (91.66%)163
sh1 (3.70%)4 (0.12%)4
yaml2 (7.41%)135 (3.99%)67
yml1 (3.70%)36 (1.07%)36
\ No newline at end of file diff --git a/html/files_by_date.dat b/html/files_by_date.dat new file mode 100644 index 0000000..6e0d813 --- /dev/null +++ b/html/files_by_date.dat @@ -0,0 +1,57 @@ +2014-09-09 1 +2014-09-09 5 +2014-09-09 6 +2014-09-10 6 +2014-09-11 6 +2014-09-12 6 +2014-09-13 6 +2014-09-17 11 +2014-09-17 6 +2014-09-18 11 +2014-09-19 11 +2014-09-20 15 +2014-09-20 16 +2014-09-20 17 +2014-09-22 17 +2014-09-23 17 +2014-09-24 17 +2014-09-26 17 +2014-09-29 17 +2014-10-06 17 +2014-10-08 17 +2014-10-09 17 +2014-10-10 17 +2014-10-15 18 +2014-10-16 17 +2014-10-16 18 +2014-10-17 17 +2014-10-17 18 +2014-10-20 17 +2014-10-20 18 +2014-10-21 17 +2014-10-22 18 +2014-10-24 17 +2014-10-24 18 +2014-10-28 17 +2014-10-28 18 +2014-10-30 17 +2014-10-30 18 +2014-11-03 18 +2014-11-04 19 +2014-11-09 18 +2014-11-09 19 +2014-11-10 20 +2014-11-11 19 +2014-11-11 21 +2014-11-11 22 +2014-11-11 24 +2014-11-11 25 +2014-11-13 25 +2014-11-14 25 +2014-11-17 25 +2014-12-04 25 +2014-12-06 25 +2014-12-07 25 +2014-12-07 27 +2014-12-09 27 +2014-12-11 27 diff --git a/html/files_by_date.plot b/html/files_by_date.plot new file mode 100644 index 0000000..e5b372a --- /dev/null +++ b/html/files_by_date.plot @@ -0,0 +1,15 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set output 'files_by_date.png' +unset key +set yrange [0:] +set xdata time +set timefmt "%Y-%m-%d" +set format x "%Y-%m-%d" +set grid y +set ylabel "Files" +set xtics rotate +set ytics autofreq +set bmargin 6 +plot 'files_by_date.dat' using 1:2 w steps diff --git a/html/files_by_date.png b/html/files_by_date.png new file mode 100644 index 0000000000000000000000000000000000000000..d873daf00cc9e8b989e1f1f879f8c89bb9cf3a10 GIT binary patch literal 2793 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 literal 0 HcmV?d00001 diff --git a/html/gitstats.cache b/html/gitstats.cache new file mode 100644 index 0000000000000000000000000000000000000000..75a8fef19c0a896753d934feacfff7a8eb008deb GIT binary patch literal 4601 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 literal 0 HcmV?d00001 diff --git a/html/gitstats.css b/html/gitstats.css new file mode 100644 index 0000000..d807cb0 --- /dev/null +++ b/html/gitstats.css @@ -0,0 +1,145 @@ +/** + * GitStats - default style + */ +body { + color: black; + background-color: #dfd; +} + +dt { + font-weight: bold; + float: left; + margin-right: 1em; +} + +dt:after { + content: ': '; +} + +dd { + display: block; + clear: left; +} + +table { + border: 1px solid black; + border-collapse: collapse; + font-size: 80%; + margin-bottom: 1em; +} + +table.noborders { + border: none; +} + +table.noborders td { + border: none; +} + +.vtable { + float: right; + clear: both; +} + +table.tags td { + vertical-align: top; +} + +td { + background-color: white; +} + +th { + background-color: #ddf; +} + +th a { + text-decoration: none; +} + +tr:hover { + background-color: #ddf; +} + +td { + border: 1px solid black; + padding: 0.2em; + padding-left: 0.3em; + padding-right: 0.2em; +} + +/* Navigation bar; tabbed style */ +.nav { + border-bottom: 1px solid black; + padding: 0.3em; +} + +.nav ul { + list-style-type: none; + display: inline; + margin: 0; + padding: 0; +} + +.nav li { + display: inline; +} + +.nav li a { + padding: 0.3em; + text-decoration: none; + color: black; + border: 1px solid black; + margin: 0.5em; + background-color: #ddf; +} + +.nav li a:hover { + background-color: #ddd; + border-bottom: 1px solid #ddf; +} + +img { + border: 1px solid black; + padding: 0.5em; + background-color: white; +} + +th img { + border: 0px; + padding: 0px; + background-color: #ddf; +} + +h1 a, h2 a { + color: black; + text-decoration: none; +} + +h1:hover a:after, +h2:hover a:after { + content: '¶'; + color: #555; +} + +h1 { + font-size: x-large; +} + +h2 { + background-color: #564; + border: 1px solid black; + padding-left: 0.5em; + padding-right: 0.5em; + color: white; + font-size: large; + clear: both; +} + +h2 a { + color: white; +} + +.moreauthors { + font-size: 80%; +} diff --git a/html/hour_of_day.dat b/html/hour_of_day.dat new file mode 100644 index 0000000..630f59e --- /dev/null +++ b/html/hour_of_day.dat @@ -0,0 +1,24 @@ +1 1 +2 0 +3 0 +4 0 +5 0 +6 9 +7 4 +8 0 +9 1 +10 6 +11 5 +12 17 +13 12 +14 12 +15 10 +16 15 +17 9 +18 8 +19 2 +20 9 +21 8 +22 6 +23 15 +24 4 diff --git a/html/hour_of_day.plot b/html/hour_of_day.plot new file mode 100644 index 0000000..0affd30 --- /dev/null +++ b/html/hour_of_day.plot @@ -0,0 +1,11 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set output 'hour_of_day.png' +unset key +set xrange [0.5:24.5] +set yrange [0:] +set xtics 4 +set grid y +set ylabel "Commits" +plot 'hour_of_day.dat' using 1:2:(0.5) w boxes fs solid diff --git a/html/hour_of_day.png b/html/hour_of_day.png new file mode 100644 index 0000000000000000000000000000000000000000..be70f4fb72ddf7e6bda7c54b676f474d40ab9052 GIT binary patch literal 3114 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 literal 0 HcmV?d00001 diff --git a/html/index.html b/html/index.html new file mode 100644 index 0000000..fb31173 --- /dev/null +++ b/html/index.html @@ -0,0 +1,23 @@ + + + + + GitStats - VTTools + + + + + +

GitStats - VTTools

+
+ +
+
Project name
VTTools
Generated
2015-01-30 10:43:20 (in 0 seconds)
Generator
GitStats (version a5a9b09), git version 2.1.0, gnuplot 4.6 patchlevel 5
Report Period
2014-09-09 16:46:21 to 2014-12-11 16:24:29
Age
94 days, 40 active days (42.55%)
Total Files
27
Total Lines of Code
3380 (4361 added, 981 removed)
Total Commits
153 (average 3.8 commits per active day, 1.6 per all days)
Authors
7 (average 21.9 commits per author)
+ \ No newline at end of file diff --git a/html/lines.html b/html/lines.html new file mode 100644 index 0000000..6829204 --- /dev/null +++ b/html/lines.html @@ -0,0 +1,27 @@ + + + + + GitStats - VTTools + + + + + +

Lines

+
+ +
+
+
Total lines
3380
+ +

Lines of Code

+ + \ No newline at end of file diff --git a/html/lines_of_code.dat b/html/lines_of_code.dat new file mode 100644 index 0000000..0c37ce3 --- /dev/null +++ b/html/lines_of_code.dat @@ -0,0 +1,38 @@ +1410295581 28 +1410295903 678 +1410298005 773 +1410309908 775 +1410355340 848 +1410461076 844 +1410471462 837 +1410539586 766 +1410539655 766 +1410549087 780 +1411006669 789 +1411051546 1685 +1411057642 1692 +1411136918 1699 +1411144306 1715 +1411145842 1715 +1411148715 1715 +1411485630 2213 +1411487201 2212 +1411488438 2212 +1411758852 2211 +1412011481 2220 +1412946301 2226 +1413577844 2226 +1413577966 2227 +1413831813 2252 +1414525888 2490 +1414555083 2768 +1414694596 2762 +1415701685 2850 +1415702031 2847 +1415982861 3292 +1415989897 3298 +1417982156 3298 +1418150502 3319 +1418159469 3364 +1418326503 3377 +1418333069 3380 diff --git a/html/lines_of_code.plot b/html/lines_of_code.plot new file mode 100644 index 0000000..7f2088c --- /dev/null +++ b/html/lines_of_code.plot @@ -0,0 +1,14 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set output 'lines_of_code.png' +unset key +set yrange [0:] +set xdata time +set timefmt "%s" +set format x "%Y-%m-%d" +set grid y +set ylabel "Lines" +set xtics rotate +set bmargin 6 +plot 'lines_of_code.dat' using 1:2 w lines diff --git a/html/lines_of_code.png b/html/lines_of_code.png new file mode 100644 index 0000000000000000000000000000000000000000..3a02e085164c07bfe74990e987b765651e019f65 GIT binary patch literal 2957 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 SWaP96fQ_Yt#XU3Mgnt7^wO-%= literal 0 HcmV?d00001 diff --git a/html/lines_of_code_by_author.dat b/html/lines_of_code_by_author.dat new file mode 100644 index 0000000..ff06fca --- /dev/null +++ b/html/lines_of_code_by_author.dat @@ -0,0 +1,150 @@ +1410295581 28 0 0 0 0 0 0 +1410295903 685 0 0 0 0 0 0 +1410298005 784 0 0 0 0 0 0 +1410307531 784 0 4 0 0 0 0 +1410309908 784 0 4 0 0 0 0 +1410355340 873 0 4 0 0 0 0 +1410461076 883 0 4 0 0 0 0 +1410471462 909 0 4 0 0 0 0 +1410484387 909 0 4 0 0 0 0 +1410539586 910 0 4 0 0 0 0 +1410539655 910 0 4 0 0 0 0 +1410544965 933 0 4 0 0 0 0 +1410547908 969 0 4 0 0 0 0 +1410548603 972 0 4 0 0 0 0 +1410548944 973 0 4 0 0 0 0 +1410549087 973 0 4 0 0 0 0 +1410665665 985 0 4 0 0 0 0 +1411006353 1912 0 4 0 0 0 0 +1411006382 1913 0 4 0 0 0 0 +1411006470 1914 0 4 0 0 0 0 +1411006512 1954 0 4 0 0 0 0 +1411006669 1954 0 4 0 0 0 0 +1411007173 1958 0 4 0 0 0 0 +1411009106 1967 0 4 0 0 0 0 +1411051546 1967 0 4 0 0 0 0 +1411055425 1990 0 4 0 0 0 0 +1411057176 1991 0 4 0 0 0 0 +1411057642 1991 0 4 0 0 0 0 +1411076409 1991 1 4 0 0 0 0 +1411131939 2005 1 4 0 0 0 0 +1411136918 2005 1 4 0 0 0 0 +1411143263 2021 1 4 0 0 0 0 +1411144306 2021 1 4 0 0 0 0 +1411145807 2022 1 4 0 0 0 0 +1411145842 2022 1 4 0 0 0 0 +1411148715 2022 1 4 0 0 0 0 +1411221344 2275 1 4 0 0 0 0 +1411222174 2342 1 4 0 0 0 0 +1411222943 2354 1 4 0 0 0 0 +1411225228 2501 1 4 0 0 0 0 +1411225419 2505 1 4 0 0 0 0 +1411225924 2508 1 4 0 0 0 0 +1411264370 2726 1 4 0 0 0 0 +1411400322 2730 1 4 0 0 0 0 +1411485597 2730 1 4 0 11 0 0 +1411485630 2730 1 4 0 11 0 0 +1411487201 2730 1 4 0 11 0 0 +1411488438 2731 1 4 0 11 0 0 +1411602878 2731 1 14 0 11 0 0 +1411602919 2731 1 18 0 11 0 0 +1411602974 2731 1 171 0 11 0 0 +1411603118 2731 1 174 0 11 0 0 +1411603285 2731 1 174 0 11 0 0 +1411603414 2731 1 190 0 11 0 0 +1411611758 2731 1 191 0 11 0 0 +1411611862 2731 1 198 0 11 0 0 +1411612232 2731 1 201 0 11 0 0 +1411612864 2731 1 202 0 11 0 0 +1411758852 2732 1 202 0 11 0 0 +1411760051 2732 43 202 0 11 0 0 +1411760654 2732 48 202 0 11 0 0 +1411790072 2732 179 202 0 11 0 0 +1412006449 2732 179 202 0 20 0 0 +1412011481 2732 179 202 0 20 0 0 +1412025015 2732 200 202 0 20 0 0 +1412606172 2732 200 202 1 20 0 0 +1412798116 2732 200 202 7 20 0 0 +1412861933 2732 200 202 8 20 0 0 +1412946301 2732 200 202 8 20 0 0 +1413386403 2732 388 202 8 20 0 0 +1413487584 2732 443 202 8 20 0 0 +1413488272 2732 443 202 8 20 0 0 +1413489010 2732 443 202 8 20 0 0 +1413491521 2732 445 202 8 20 0 0 +1413497889 2732 542 202 8 20 0 0 +1413505489 2732 851 202 8 20 0 0 +1413507110 2732 864 202 8 20 0 0 +1413508745 2732 864 202 8 20 0 0 +1413510104 2732 876 202 8 20 0 0 +1413511413 2732 1088 202 8 20 0 0 +1413511794 2732 1138 202 8 20 0 0 +1413570999 2732 1145 202 8 20 0 0 +1413577844 2736 1145 202 8 20 0 0 +1413577966 2738 1145 202 8 20 0 0 +1413578459 2738 1151 202 8 20 0 0 +1413579084 2738 1152 202 8 20 0 0 +1413819476 2738 1152 202 32 20 0 0 +1413819615 2738 1152 202 32 20 0 0 +1413820012 2738 1152 202 39 20 0 0 +1413820140 2738 1152 202 39 20 0 0 +1413820306 2738 1152 202 45 20 0 0 +1413831813 2738 1152 202 45 20 0 0 +1413845407 2738 1158 202 45 20 0 0 +1413848238 2738 1161 202 45 20 0 0 +1413849155 2738 1168 202 45 20 0 0 +1413849503 2738 1175 202 45 20 0 0 +1413855558 2738 1185 202 45 20 0 0 +1413855728 2738 1275 202 45 20 0 0 +1413859749 2738 1279 202 45 20 0 0 +1413860027 2738 1295 202 45 20 0 0 +1413904720 2738 1305 202 45 20 0 0 +1413985972 2738 1305 202 45 20 0 0 +1414002032 2738 1312 202 45 20 0 0 +1414002161 2738 1329 202 45 20 0 0 +1414014852 2738 1330 202 45 20 0 0 +1414015108 2738 1349 202 45 20 0 0 +1414170215 2738 1385 202 45 20 0 0 +1414170594 2738 1393 202 45 20 0 0 +1414171018 2738 1397 202 45 20 0 0 +1414171440 2738 1399 202 45 20 0 0 +1414184835 2738 1400 202 45 20 0 0 +1414525388 2738 1400 211 45 20 0 0 +1414525888 2738 1400 211 45 20 0 0 +1414555083 2738 1400 211 45 20 0 0 +1414694123 2738 1404 211 45 20 0 0 +1414694596 2738 1404 211 45 20 0 0 +1414697598 2738 1404 211 45 33 0 0 +1415040467 2738 1404 211 45 115 0 0 +1415108847 2811 1404 211 45 115 0 0 +1415556923 2811 1404 211 45 209 0 0 +1415558473 2811 1404 211 45 209 0 0 +1415656887 3135 1404 211 45 209 0 0 +1415701333 3894 1404 211 45 209 0 0 +1415701685 3894 1404 211 45 209 0 0 +1415701963 3894 1404 211 45 209 0 0 +1415702031 3894 1404 211 45 209 0 0 +1415702124 3894 1404 211 45 209 0 0 +1415702345 3931 1404 211 45 209 0 0 +1415702482 3933 1404 211 45 209 0 0 +1415702795 3938 1404 211 45 209 0 0 +1415703024 3939 1404 211 45 209 0 0 +1415703740 3942 1404 211 45 209 0 0 +1415703871 3944 1404 211 45 209 0 0 +1415704040 3945 1404 211 45 209 0 0 +1415704198 3949 1404 211 45 209 0 0 +1415722431 3949 1404 211 45 209 0 0 +1415899718 3989 1404 211 45 209 0 0 +1415982861 3989 1404 211 45 209 0 0 +1415989897 4005 1404 211 45 209 0 0 +1416201507 4005 1404 211 45 232 0 0 +1416243835 4005 1404 211 45 264 0 0 +1417724482 4005 1404 211 45 264 2 0 +1417928180 4005 1404 211 45 264 3 0 +1417982156 4005 1404 211 45 264 3 0 +1418000682 4005 1404 253 45 264 3 0 +1418001563 4005 1404 272 45 264 3 0 +1418150502 4005 1404 272 45 264 3 0 +1418159469 4005 1404 272 45 264 3 0 +1418326503 4020 1404 272 45 264 3 0 +1418333069 4023 1404 272 45 264 3 0 diff --git a/html/lines_of_code_by_author.plot b/html/lines_of_code_by_author.plot new file mode 100644 index 0000000..f901fcf --- /dev/null +++ b/html/lines_of_code_by_author.plot @@ -0,0 +1,15 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set terminal png transparent size 640,480 +set output 'lines_of_code_by_author.png' +set key left top +set yrange [0:] +set xdata time +set timefmt "%s" +set format x "%Y-%m-%d" +set grid y +set ylabel "Lines" +set xtics rotate +set bmargin 6 +plot 'lines_of_code_by_author.dat' using 1:2 title "Eric Dill" w lines, 'lines_of_code_by_author.dat' using 1:3 title "Gabriel Iltis" w lines, 'lines_of_code_by_author.dat' using 1:4 title "Thomas A Caswell" w lines, 'lines_of_code_by_author.dat' using 1:5 title "Sameera Abeykoon" w lines, 'lines_of_code_by_author.dat' using 1:6 title "licode" w lines, 'lines_of_code_by_author.dat' using 1:7 title "Wei Xu" w lines, 'lines_of_code_by_author.dat' using 1:8 title "Li Li" w lines diff --git a/html/lines_of_code_by_author.png b/html/lines_of_code_by_author.png new file mode 100644 index 0000000000000000000000000000000000000000..847cb4e62c7b19b689ea24ce1f1f505adf672037 GIT binary patch literal 6304 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 literal 0 HcmV?d00001 diff --git a/html/month_of_year.dat b/html/month_of_year.dat new file mode 100644 index 0000000..06131f1 --- /dev/null +++ b/html/month_of_year.dat @@ -0,0 +1,12 @@ +1 0 +2 0 +3 0 +4 0 +5 0 +6 0 +7 0 +8 0 +9 65 +10 52 +11 25 +12 11 diff --git a/html/month_of_year.plot b/html/month_of_year.plot new file mode 100644 index 0000000..7e4bc7d --- /dev/null +++ b/html/month_of_year.plot @@ -0,0 +1,11 @@ +set terminal png transparent size 640,240 +set size 1.0,1.0 + +set output 'month_of_year.png' +unset key +set xrange [0.5:12.5] +set yrange [0:] +set xtics 1 +set grid y +set ylabel "Commits" +plot 'month_of_year.dat' using 1:2:(0.5) w boxes fs solid diff --git a/html/month_of_year.png b/html/month_of_year.png new file mode 100644 index 0000000000000000000000000000000000000000..e2be75991f4f9f888accaed30c5ef63d4252cfe3 GIT binary patch literal 2703 zcmb_ddpK0<8eeP7XpHNG%2a01W%i&nDk_aNb3{65FuJKsr8K3CQd_yqXDAg)CyCk0 zs7R^dbTQ<%97zd@ibAHnLnX7P!Y*W;HP!Q+z0dP>{yOXSz3=zE-}hdB?>fr&@i3&& zC=di0dMvv1)m7qXyG7D$ijUieUglQA{qz0WsKguYI>93q#qmsd$47Y1^`UL$IMPaO^+}Lzp=!o zeh6xWAYfr3hM*(}!saBcwobB!FbNcla}d@B6{^)(akaWjs=_c$faY3zZ>l;~!)D{| z^z`&JG&G{)~vdFFq({p+sb z(>}t`BjtxhP7)40v1Q~qogg(V>`-3@j;Nk5DQgy1C!%Xy{Q2Xlst%*9y0vB>hkm7$ zyohV_)kI7o*{E!c#zNtk*4ZgRRZVrBXY?pmib)-hMmCLySkmB^2@&fUj4S|z6oT|8 zGC7aI$dLYr5ndi!TsLy_I74`uAzwSo#H88IluX{9u16%!e?TMoaULA#y!}O9 z7gJ4jtPWwBi8sp7jRtP0LB20iO8Wc0jDmWy_s7wnYdmBp^x?hEw_NGrwl)TVo2HBa z3;rhk_WR5dx-7MxtUc`Y;qX$O69V^pQVJ;Z z-!+A06O0@psAG_C#O>Wt5N|6nie=_-=D#gYXdy;ilTf|;If=2Edgu8v;1_v);Frr4 zOHJK!=EG+Yr?R;&JoKg+Q{|j67Ece6GSgU@#jba&8z>5a6-mXpe=t%M74 zJq|JJkG<{Ah_z>&rsgM$$H@7~a&q*7lcq7~G^Tf~)Xl+P z0}%hc2Jq$D%?aOj-g8ma;CwGkcNY=Z#-AKkn5G^;6MeHleJ#2BYv361sfoTaAVWnR zCz|d?M6EF8&m+G{cW?2u7cI;SK|}czZ9iuSH4 zw|&&#)#*_k>ZQa3&{vZ^``t$n>h%z`5ThGytL*(=>>7RaEMxad5n;zD_-3fk@rrx( zJT}+hn5kyb_k^0w61skNy`4Qb$sN6!Hd8)z6?`c>%#f>PgiaOXd$KkjKc{Eyn+`^= zTF$kNrfk)7&K?^$=VfxVgP3f)vk2S-#yNKIA48wEjMli3Gcv9dJInXF9E-vw+am^E z)0~W2`Bd(K%18$7 z8J20TGd>mT^o38#-a<8jsSdU<>{IeLw3Wj^Sa^qqF8+FxO+eU9ESo?5sAhyn%5o0> zB-|gh_?fBZxNnr@SqV@?Hw-*K(9B6SI5@vsxwqil>oYf+iB&OAUIkq3rKsmwt#;5G z?J!&raVju2eQ^PAGs$WD!wZIyC^JMQwLD5+eKP2^Km2ik|#$eR`tBEk6Vxu?SJ{xf=FDxU`?%7ULj-? z&cq+es^sjaJ?W!fzr&N9=^T&qd&+>nIQ0iqhi!C>pmw}gsDkDhPZsYI2=agTec-)9 zVp-GjrDb@|%!L+AAOzI{IR*KS@ul1^lf&@ zc<-w~WM9||<4m31)jv}*x>-Fy|M%NPPXoI=*Xb=PQD1F4d2wXw+c2M(ftFcs+f-_f z@U^)Y7XUbBMDsp<*k#Nx;MtYWbmjG1p}fkVR4^Wrb858ES5uewb~ZuxMEyh)2jeLY z*;LMN5gznr`|yf!yFs0Ia_*5a+V)=f7iFQW{KzgI(V$c+BFnx=Nc{@G$&33GyWuhr zV#hVM4HG)&S?crNpC JQ}Be+e*-A&j4l8G literal 0 HcmV?d00001 diff --git a/html/sortable.js b/html/sortable.js new file mode 100644 index 0000000..8947732 --- /dev/null +++ b/html/sortable.js @@ -0,0 +1,324 @@ +/* +Table sorting script by Joost de Valk, check it out at http://www.joostdevalk.nl/code/sortable-table/. +Based on a script from http://www.kryogenix.org/code/browser/sorttable/. +Distributed under the MIT license: http://www.kryogenix.org/code/browser/licence.html . + +Copyright (c) 1997-2007 Stuart Langridge, Joost de Valk. + +Version 1.5.7 +*/ + +/* You can change these values */ +var image_path = ""; +var image_up = "arrow-up.gif"; +var image_down = "arrow-down.gif"; +var image_none = "arrow-none.gif"; +var europeandate = true; +var alternate_row_colors = true; + +/* Don't change anything below this unless you know what you're doing */ +addEvent(window, "load", sortables_init); + +var SORT_COLUMN_INDEX; +var thead = false; + +function sortables_init() { + // Find all tables with class sortable and make them sortable + if (!document.getElementsByTagName) return; + tbls = document.getElementsByTagName("table"); + for (ti=0;ti 0) { + if (t.tHead && t.tHead.rows.length > 0) { + var firstRow = t.tHead.rows[t.tHead.rows.length-1]; + thead = true; + } else { + var firstRow = t.rows[0]; + } + } + if (!firstRow) return; + + // We have a first row: assume it's the header, and make its contents clickable links + for (var i=0;i'+txt+'  ↓'; + } + } + if (alternate_row_colors) { + alternate(t); + } +} + +function ts_getInnerText(el) { + if (typeof el == "string") return el; + if (typeof el == "undefined") { return el }; + if (el.innerText) return el.innerText; //Not needed but it is faster + var str = ""; + + var cs = el.childNodes; + var l = cs.length; + for (var i = 0; i < l; i++) { + switch (cs[i].nodeType) { + case 1: //ELEMENT_NODE + str += ts_getInnerText(cs[i]); + break; + case 3: //TEXT_NODE + str += cs[i].nodeValue; + break; + } + } + return str; +} + +function ts_resortTable(lnk, clid) { + var span; + for (var ci=0;ci'; + newRows.reverse(); + span.setAttribute('sortdir','up'); + } else { + ARROW = '  ↑'; + span.setAttribute('sortdir','down'); + } + // We appendChild rows that already exist to the tbody, so it moves them rather than creating new ones + // don't do sortbottom rows + for (i=0; i'; + } + } + } + span.innerHTML = ARROW; + alternate(t); +} + +function getParent(el, pTagName) { + if (el == null) { + return null; + } else if (el.nodeType == 1 && el.tagName.toLowerCase() == pTagName.toLowerCase()) { + return el; + } else { + return getParent(el.parentNode, pTagName); + } +} + +function sort_date(date) { + // y2k notes: two digit years less than 50 are treated as 20XX, greater than 50 are treated as 19XX + dt = "00000000"; + if (date.length == 11) { + mtstr = date.substr(3,3); + mtstr = mtstr.toLowerCase(); + switch(mtstr) { + case "jan": var mt = "01"; break; + case "feb": var mt = "02"; break; + case "mar": var mt = "03"; break; + case "apr": var mt = "04"; break; + case "may": var mt = "05"; break; + case "jun": var mt = "06"; break; + case "jul": var mt = "07"; break; + case "aug": var mt = "08"; break; + case "sep": var mt = "09"; break; + case "oct": var mt = "10"; break; + case "nov": var mt = "11"; break; + case "dec": var mt = "12"; break; + // default: var mt = "00"; + } + dt = date.substr(7,4)+mt+date.substr(0,2); + return dt; + } else if (date.length == 10) { + if (europeandate == false) { + dt = date.substr(6,4)+date.substr(0,2)+date.substr(3,2); + return dt; + } else { + dt = date.substr(6,4)+date.substr(3,2)+date.substr(0,2); + return dt; + } + } else if (date.length == 8) { + yr = date.substr(6,2); + if (parseInt(yr) < 50) { + yr = '20'+yr; + } else { + yr = '19'+yr; + } + if (europeandate == true) { + dt = yr+date.substr(3,2)+date.substr(0,2); + return dt; + } else { + dt = yr+date.substr(0,2)+date.substr(3,2); + return dt; + } + } + return dt; +} + +function ts_sort_date(a,b) { + dt1 = sort_date(ts_getInnerText(a.cells[SORT_COLUMN_INDEX])); + dt2 = sort_date(ts_getInnerText(b.cells[SORT_COLUMN_INDEX])); + + if (dt1==dt2) { + return 0; + } + if (dt1 + + + + GitStats - VTTools + + + + + +

Tags

+
+ +
+
Total tags
1
Average commits per tag
153.00
NameDateCommitsAuthors
0.0.02014-12-07143Eric Dill (58), Gabriel Iltis (41), Thomas A Caswell (23), Sameera Abeykoon (10), licode (7), Wei Xu (2), Li Li (2)
\ No newline at end of file diff --git a/vttools/tests/__init__.py b/vttools/tests/__init__.py index 8b13789..06e0246 100644 --- a/vttools/tests/__init__.py +++ b/vttools/tests/__init__.py @@ -1 +1,36 @@ - +# ###################################################################### +# Copyright (c) 2014, Brookhaven Science Associates, Brookhaven # +# National Laboratory. All rights reserved. # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions # +# are met: # +# # +# * Redistributions of source code must retain the above copyright # +# notice, this list of conditions and the following disclaimer. # +# # +# * 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. # +# # +# * Neither the name of the Brookhaven Science Associates, Brookhaven # +# National Laboratory 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 OTHERWISE) ARISING # +# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # +# POSSIBILITY OF SUCH DAMAGE. # +######################################################################## +import logging +logger = logging.getLogger(__name__) From 102feb308da41fa47ff056fbb0b87546eee18041 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Fri, 10 Apr 2015 15:32:10 -0400 Subject: [PATCH 17/33] TST: Img arith tool test. Changed tool location and refs to srch vttool Simple term replacement. Replaced all references to mathops by changing import statement to: import vttools.to_wrap.image_proc as img The tests included focus on the vistrails specific functions: arithmetic_basic, logic_basic, and arithmetic_custom --- vttools/tests/test_img_proc.py | 88 +++++++++++++++++----------------- 1 file changed, 44 insertions(+), 44 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 43e5b10..458b4a5 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -12,7 +12,7 @@ import numpy as np import six -from skxray.img_proc import mathops +import vttools.to_wrap.image_proc as img from numpy.testing import assert_equal, assert_raises @@ -63,29 +63,29 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_1, test_constant_int) div_check = np.divide(test_array_1, test_constant_int) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'multiplication'), mult_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_int, 'division'), div_check) assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_1, test_array_1, 'division') assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_1, 0, 'division') @@ -96,20 +96,20 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_1, test_array_2) div_check = np.divide(test_array_1, test_array_2) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_2, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_2, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_2, 'multiplication'), mult_check) assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_2, test_array_1, 'division') @@ -120,19 +120,19 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_3, test_constant_flt) div_check = np.divide(test_array_3, test_constant_flt) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'multiplication'), mult_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_flt, 'division'), div_check) @@ -142,40 +142,40 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_3, test_array_3) div_check = np.divide(test_array_3, test_array_3) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'addition'), add_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'subtraction'), sub_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'multiplication'), mult_check) - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_array_3, 'division'), div_check) #Mixed dtypes: Int array and float array - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_array_1.astype(float), 'addition').dtype, float) #Float array and int constant - assert_equal(mathops.arithmetic_basic(test_array_3, + assert_equal(img.arithmetic_basic(test_array_3, test_constant_int, 'addition').dtype, float) #Int array and float constant - assert_equal(mathops.arithmetic_basic(test_array_1, + assert_equal(img.arithmetic_basic(test_array_1, test_constant_flt, 'addition').dtype, float) #Mismatched array sizes assert_raises(ValueError, - mathops.arithmetic_basic, + img.arithmetic_basic, test_array_1, test_array_3, 'addition') @@ -210,7 +210,7 @@ def test_arithmetic_custom(): #-int only result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + test_array_5 + test_array_6 + test_array_7 + test_array_8) - assert_equal(mathops.arithmetic_custom('A+B+C+D+E+F+G+H', + assert_equal(img.arithmetic_custom('A+B+C+D+E+F+G+H', test_array_1, test_array_2, test_array_3, @@ -225,7 +225,7 @@ def test_arithmetic_custom(): (test_array_3.astype(float) / 2.0) - test_array_4.astype(float) ) - assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', test_array_1.astype(float), 3.5, test_array_3.astype(float), @@ -237,14 +237,14 @@ def test_arithmetic_custom(): (test_array_3.astype(float) / 2) - test_array_4 ) - assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', test_array_1, 3.5, test_array_3.astype(float), 2, test_array_4.astype(float)), result) - assert_equal(mathops.arithmetic_custom('(A+B)+(C/D)-E', + assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', test_array_1, 3.5, test_array_3.astype(float), @@ -272,21 +272,21 @@ def test_logic(): test_array_3[40:89, 40:89, 40:89] = 3 #and - assert_equal(mathops.logic_basic('and', test_array_1, test_array_1), + assert_equal(img.logic_basic('and', test_array_1, test_array_1), test_array_1) - test_result = mathops.logic_basic('and', test_array_1, test_array_2) + test_result = img.logic_basic('and', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], True) assert_equal(test_result.sum(), ((39-20)**3)) - test_result = mathops.logic_basic('and', test_array_1, test_array_3) + test_result = img.logic_basic('and', test_array_1, test_array_3) assert_equal(test_result, False) #or - assert_equal(mathops.logic_basic('or', test_array_1, test_array_1), + assert_equal(img.logic_basic('or', test_array_1, test_array_1), test_array_1) - assert_equal(mathops.logic_basic('or', + assert_equal(img.logic_basic('or', test_array_1, test_array_2).sum(), (test_array_1.sum() + @@ -296,7 +296,7 @@ def test_logic(): test_array_2).sum() ) ) - test_result = mathops.logic_basic('or', test_array_1, test_array_3) + test_result = img.logic_basic('or', test_array_1, test_array_3) assert_equal(test_result.sum(), (test_array_1.sum() + test_array_3.sum() / @@ -305,15 +305,15 @@ def test_logic(): ) #not - assert_equal(mathops.logic_basic('not', test_array_1).sum(), + assert_equal(img.logic_basic('not', test_array_1).sum(), (90**3-test_array_1.sum())) - assert_equal(mathops.logic_basic('not', test_array_3).sum(), + assert_equal(img.logic_basic('not', test_array_3).sum(), (90**3-(test_array_3.sum()/test_array_3.max()))) #xor - assert_equal(mathops.logic_basic('xor', test_array_1, test_array_1), + assert_equal(img.logic_basic('xor', test_array_1, test_array_1), np.zeros((90,90,90), dtype=int)) - assert_equal(mathops.logic_basic('xor', + assert_equal(img.logic_basic('xor', test_array_1, test_array_2).sum(), ((test_array_1.sum() + @@ -325,15 +325,15 @@ def test_logic(): ) #nand - assert_equal(mathops.logic_basic('nand', test_array_1, test_array_1), + assert_equal(img.logic_basic('nand', test_array_1, test_array_1), np.logical_not(test_array_1)) - test_result = mathops.logic_basic('nand', test_array_1, test_array_2) + test_result = img.logic_basic('nand', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) #nor - assert_equal(mathops.logic_basic('nor', test_array_1, test_array_1), + assert_equal(img.logic_basic('nor', test_array_1, test_array_1), np.logical_not(test_array_1)) - assert_equal(mathops.logic_basic('nor', + assert_equal(img.logic_basic('nor', test_array_1, test_array_2).sum(), (np.ones((90,90,90), dtype=int).sum() - @@ -344,9 +344,9 @@ def test_logic(): ) #subtract - assert_equal(mathops.logic_basic('subtract', test_array_1, test_array_1), + assert_equal(img.logic_basic('subtract', test_array_1, test_array_1), False) - test_result = mathops.logic_basic('subtract', test_array_1, test_array_2) + test_result = img.logic_basic('subtract', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) assert_equal(test_result.sum(), (test_array_1.sum() - @@ -354,7 +354,7 @@ def test_logic(): test_array_2).sum() ) ) - test_result = mathops.logic_basic('subtract', test_array_1, test_array_3) + test_result = img.logic_basic('subtract', test_array_1, test_array_3) assert_equal(test_result, test_array_1) From 98c3f367ff128468ea353955954a34b11989407c Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 01:54:15 -0400 Subject: [PATCH 18/33] DEV: Mod to arith_custom docs. Removed additional operators. Previously the docstring for arithmetic_custom included references to additional operators such as +=, -=, *= etc. which are supposed to simplify expressions like a=a+b, which is the equivalent of a+=b. However, the parsing function does not evaluate these short cuts correctly. If these additional operators become important, then I'll revisit and modify the parsing function, or write a custom one. However, at this time the additional operators are deemed to be unnecessary, since the expressions can still be evaluated without the operators.` --- vttools/to_wrap/image_proc.py | 35 +---------------------------------- 1 file changed, 1 insertion(+), 34 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index eeae89e..3e8189d 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -128,40 +128,7 @@ def arithmetic_custom(expression, >= : greater than or equal <= : less than or equal - Additional operators: - = : assignment operator (assigns values from right side to those - on the left side) - += : Adds the right operand to the left operand and sets the - total equal to the left operand, - e.g.: - b+=a is equivalent to b=a+b - -= : Subtracts the right operand from the left operand and sets - the total equal to the left operand, - e.g.: - b -= a is equivalent to b = b - a - *= : multiplies the right operand to the left operand and sets the - total equal to the left operand, - e.g.: - b *= a is equivalent to b = b * a - /= : divides the right operand into the left operand and sets the - total equal to the left operand, - e.g.: - b /= a is equivalent to b = b / a - %= : divides the right operand into the left operand and sets the - remainder equal to the left operand, - e.g.: - b %= a is equivalent to b =b % a - **= : raises the left operand to the power of the right operand - and sets the total equal to the left operand, - e.g.: - b **= a is equivalent to b = b ** a - //= : divides the right operand into the left operand and - then removes any values after the decimal point. The total - is then set equal to the left operand, - e.g.: - b //= a is equivalent to b = b // a - - In the event that bitwise operations are required the operators &, ++- In the event that bitwise operations are required the operators &, |, ^, ~ may also be used, though I'm struggling to come up with a scenario where this will be used. From 5545161d9c3353d98b1731e3e2fe46a5c64ae0ae Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 02:22:02 -0400 Subject: [PATCH 19/33] DEV: Changed data inputs to x1 and x2. Completed docstrings for funcs. As per Eric's suggestion, inputs specific to data have been renamed in order to conform to typical numpy docstrings, e.g. the arg src_data1 and src_data2 have been changed to x1 and x2. The funcs requiring a string operation to be defined have also been standardized so that the input order starts with the operation or expression followed by the input data. Finally, the docstring for arithmetic_custom was incomplete, and has been flushed out. --- vttools/to_wrap/image_proc.py | 67 +++++++++++++++++++++-------------- 1 file changed, 41 insertions(+), 26 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 3e8189d..88ea25e 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -13,9 +13,9 @@ subtract, multiply, divide) -def arithmetic_basic(input_1, - input_2, - operation): +def arithmetic_basic(operation, + x1, + x2): """ This function enables basic arithmetic for image processing and data analysis. The function is capable of applying the basic arithmetic @@ -24,26 +24,41 @@ def arithmetic_basic(input_1, Parameters ---------- - input_1 : {ndarray, int, float} - Specifies the first input data set, or constant, to be offset or - manipulated - - input_2 : {ndarray, int, float} - Specifies the second data set, or constant, to be offset or manipulated - operation : string - addition: the addition of EITHER two images or volume data sets, + addition: + The addition of EITHER two images or volume data sets, OR an image/data set and a value. This function is typically - used for offset purposes, or basic recombination of several isolated - materials or phases into a single segmented volume. - subtraction: enables the subtraction of EITHER one image or volume data + used for offset purposes, or basic recombination of several + isolated materials or phases into a single segmented volume. + subtraction: + Enables the subtraction of EITHER one image or volume data set from another, OR reduction of all values in an image/data set by a set value. This function is typically used for offset purposes, or basic isolation of objects or materials/phases in a data set. multiplication: + Enables the multiplication of input 1 (x1) by input 2 (x2). The + inputs can be of any valid numpy data type (e.g. an image or + volume data a fixed, constant, value). This function is typically + used for offset purposes (rescaling), or for assigning values in + the generation of a labelfield identifying objects or + materials/phases in a data set. division: + Enables the division of input 1 (x1, numerator) by input 2 (x2, + denominator). The inputs can be of any valid numpy data type + (e.g. an image or volume data a fixed, constant, value). Basic + tests are included in the division function which test for, + and ensure that division by zero does not occur. This function is + typically used for offset purposes (rescaling, normalization). + + x1 : {ndarray, int, float} + Specifies the first input data set, or constant, to be offset or + manipulated + + x2 : {ndarray, int, float} + Specifies the second data set, or constant, to be offset or manipulated + Returns @@ -61,19 +76,19 @@ def arithmetic_basic(input_1, 'division' : divide } if operation == 'division': - if type(input_2) is np.ndarray: - if 0 in input_2: + if type(x2) is np.ndarray: + if 0 in x2: raise ValueError("This division operation will result in " "division by zero values. Please reevaluate " - "denominator (input_2).") + "denominator (x2).") else: - if float(input_2) == 0: + if float(x2) == 0: raise ValueError("This division operation will result in " "division by a zero value. Please " "reevaluate the denominator constant" - " (input_2).") + " (x2).") - output = operation_dict[operation](input_1, input_2) + output = operation_dict[operation](x1, x2) return output @@ -174,8 +189,8 @@ def arithmetic_custom(expression, def logic_basic(operation, - src_data1, - src_data2=None): + x1, + x2=None): """ This function enables the computation of the basic logical operations oft used in image processing of two image or volume data sets. This @@ -193,10 +208,10 @@ def logic_basic(operation, 'nand' -- 2 inputs 'subtract' -- 2 inputs - src_data1 : {ndarray, int, float, list, tuple} + x1 : {ndarray, int, float, list, tuple} Specifies the first reference - src_data2 : {ndarray, int, float, list, tuple} + x2 : {ndarray, int, float, list, tuple} Specifies the second reference Returns @@ -217,8 +232,8 @@ def logic_basic(operation, 'nor' : logical_nor, 'subtract' : logical_sub } - output = logic_dict[operation](src_data1, - src_data2) + output = logic_dict[operation](x1, + x2) return output __all__ = (add, subtract, multiply, divide, logical_and, logical_or, From f4d9a17b82ff38e189885a7237f6bee97c26d423 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 02:34:20 -0400 Subject: [PATCH 20/33] DEV: Renamed functions so they're simpler and more straight forward. As discussed with Eric, we decided to shorten, simplify and make the function names more explicit about their functionality. So, logic_basic has been renamed to logic, arithmetic_basic has been renamed arithmetic, and arithmetic_custom has been changed to arithmetic_expression. In Vistrails these tools are exprected to be nested in the tool tree under an "Image Arithmetic" heading, included in the "Image Processing" tool set/kit. --- vttools/to_wrap/image_proc.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 88ea25e..596c2fa 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -13,9 +13,9 @@ subtract, multiply, divide) -def arithmetic_basic(operation, - x1, - x2): +def arithmetic(operation, + x1, + x2): """ This function enables basic arithmetic for image processing and data analysis. The function is capable of applying the basic arithmetic @@ -92,15 +92,15 @@ def arithmetic_basic(operation, return output -def arithmetic_custom(expression, - A, - B, - C=None, - D=None, - E=None, - F=None, - G=None, - H=None): +def arithmetic_expression(expression, + A, + B, + C=None, + D=None, + E=None, + F=None, + G=None, + H=None): """ This function enables more complex arithmetic to be carried out on 2 or more (current limit is 8) arrays or constants. The arithmetic expression @@ -188,9 +188,9 @@ def arithmetic_custom(expression, return output -def logic_basic(operation, - x1, - x2=None): +def logic(operation, + x1, + x2=None): """ This function enables the computation of the basic logical operations oft used in image processing of two image or volume data sets. This From 91a4547c10f38db19539d00f1c682de98a80b50e Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 13 Apr 2015 09:46:55 -0400 Subject: [PATCH 21/33] DEV: Transferred test funcs for arith tools for VT from skxray. --- vttools/to_wrap/image_proc.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 596c2fa..c1043d0 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -8,9 +8,7 @@ import numpy as np import parser -from skxray.img_proc.mathops import (logical_sub, logical_nand, logical_nor) -from numpy import (logical_xor, logical_and, logical_or, logical_not, add, - subtract, multiply, divide) +from skxray.img_proc.mathops import * def arithmetic(operation, @@ -236,5 +234,4 @@ def logic(operation, x2) return output -__all__ = (add, subtract, multiply, divide, logical_and, logical_or, - logical_nor, logical_xor, logical_not, logical_sub, logical_nand) \ No newline at end of file +__all__ = ["arithmetic", "logic", "arithmetic_custom"] From 72f0463a40b3823690e799c7aa22b70feaadf344 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 14:17:29 -0400 Subject: [PATCH 22/33] DEV: Updated functions in image_proc.py after transfer from skxray --- vttools/to_wrap/image_proc.py | 454 ++++++++++++++++------------------ 1 file changed, 217 insertions(+), 237 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index c1043d0..0ecf75f 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -1,237 +1,217 @@ -# Module for the BNL image processing project -# Developed at the NSLS-II, Brookhaven National Laboratory -# Developed by Gabriel Iltis, Oct. 2013 -""" -This module is designed to facilitate image arithmetic and logical operations -on image data sets. -""" - -import numpy as np -import parser -from skxray.img_proc.mathops import * - - -def arithmetic(operation, - x1, - x2): - """ - This function enables basic arithmetic for image processing and data - analysis. The function is capable of applying the basic arithmetic - operations (addition, subtraction, multiplication and division) to two - data set arrays, two constants, or an array and a constant. - - Parameters - ---------- - operation : string - addition: - The addition of EITHER two images or volume data sets, - OR an image/data set and a value. This function is typically - used for offset purposes, or basic recombination of several - isolated materials or phases into a single segmented volume. - subtraction: - Enables the subtraction of EITHER one image or volume data - set from another, OR reduction of all values in an image/data set - by a set value. This function is typically used for offset - purposes, or basic isolation of objects or materials/phases in a - data set. - multiplication: - Enables the multiplication of input 1 (x1) by input 2 (x2). The - inputs can be of any valid numpy data type (e.g. an image or - volume data a fixed, constant, value). This function is typically - used for offset purposes (rescaling), or for assigning values in - the generation of a labelfield identifying objects or - materials/phases in a data set. - - division: - Enables the division of input 1 (x1, numerator) by input 2 (x2, - denominator). The inputs can be of any valid numpy data type - (e.g. an image or volume data a fixed, constant, value). Basic - tests are included in the division function which test for, - and ensure that division by zero does not occur. This function is - typically used for offset purposes (rescaling, normalization). - - x1 : {ndarray, int, float} - Specifies the first input data set, or constant, to be offset or - manipulated - - x2 : {ndarray, int, float} - Specifies the second data set, or constant, to be offset or manipulated - - - - Returns - ------- - output : {ndarray, int, float} - Returns the resulting array or constant to the designated variable - - Example - ------- - result = mathops.arithmetic_basic(img_1, img_2, 'addition') - """ - operation_dict = {'addition' : add, - 'subtraction' : subtract, - 'multiplication' : multiply, - 'division' : divide - } - if operation == 'division': - if type(x2) is np.ndarray: - if 0 in x2: - raise ValueError("This division operation will result in " - "division by zero values. Please reevaluate " - "denominator (x2).") - else: - if float(x2) == 0: - raise ValueError("This division operation will result in " - "division by a zero value. Please " - "reevaluate the denominator constant" - " (x2).") - - output = operation_dict[operation](x1, x2) - return output - - -def arithmetic_expression(expression, - A, - B, - C=None, - D=None, - E=None, - F=None, - G=None, - H=None): - """ - This function enables more complex arithmetic to be carried out on 2 or - more (current limit is 8) arrays or constants. The arithmetic expression - is defined by the user, as a string, and after assignment of inputs A - through H the string is parsed into the appropriate python expression - and executed. Note that inputs C through H are optional and need only be - defined when desired or required. - - - Parameters - ---------- - expression : string - Note that the syntax of the mathematical expression must conform to - python syntax, - eg.: - using * for multiplication instead of x - using ** for exponents instead of ^ - - Arithmetic operators: - + : addition (adds values on either side of the operator - - : subtraction (subtracts values on either side of the operator - * : multiplication (multiplies values on either side of the - operator - / : division (divides the left operand (numerator) by the right - hand operand (denominator)) - % : modulus (divides the left operand (numerator) by the right - hand operand (denominator) and returns the remainder) - ** : exponent (left operand (base) is raised to the power of the - right operand (exponent)) - // : floor division (divides the left operand (numerator) by the - right hand operand (denominator), but returns the quotient - with any digits after the decimal point removed, - e.g. 9.0/2.0 = 4.0) - - Logical operations are also included and available so long as the: - > : greater than - < : less than - == : exactly equals - != : not equal - >= : greater than or equal - <= : less than or equal - -+- In the event that bitwise operations are required the operators &, - |, ^, ~ may also be used, though I'm struggling to come up with a - scenario where this will be used. - - Order of operations and parenthesis are taken into account when - evaluating the expression. - - A : {ndarray, int, float} - Data set or constant to be offset or manipulated - - B : {ndarray, int, float} - Data set or constant to be offset or manipulated - - C : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - D : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - E : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - F : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - G : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - H : {ndarray, int, float}, optional - Data set or constant to be offset or manipulated - - - Returns - ------- - output : {ndarray, int, float} - Returns the resulting array or value to the designated variable - - Example - ------- - result = mathops.arithmetic_custom('(A+C)/(B+D)', img_1, img_2, 2, 4) - """ - output = eval(parser.expr(expression).compile()) - return output - - -def logic(operation, - x1, - x2=None): - """ - This function enables the computation of the basic logical operations - oft used in image processing of two image or volume data sets. This - function can be used for data comparison, material isolation, - noise removal, or mask application/generation. - - Parameters - ---------- - operation : str - options include: - 'and' -- 2 inputs - 'or' -- 2 inputs - 'not' -- 1 input - 'xor' -- 2 inputs - 'nand' -- 2 inputs - 'subtract' -- 2 inputs - - x1 : {ndarray, int, float, list, tuple} - Specifies the first reference - - x2 : {ndarray, int, float, list, tuple} - Specifies the second reference - - Returns - ------- - output : {ndarray, bool} - Returns the result of the logical operation, which can be an array, - or a simple boolean result. - - Example - ------- - result = mathops.logic_basic('and', img_1, img_2) - """ - logic_dict = {'and' : logical_and, - 'or' : logical_or, - 'not' : logical_not, - 'xor' : logical_xor, - 'nand' : logical_nand, - 'nor' : logical_nor, - 'subtract' : logical_sub - } - output = logic_dict[operation](x1, - x2) - return output - -__all__ = ["arithmetic", "logic", "arithmetic_custom"] +# Module for the BNL image processing project +# Developed at the NSLS-II, Brookhaven National Laboratory +# Developed by Gabriel Iltis, Oct. 2013 +""" +This module is designed to facilitate image arithmetic and logical operations +on image data sets. +""" + +import numpy as np +import parser +from skxray.img_proc.mathops import * + +__all__ = ["arithmetic", "logic", "arithmetic_expression"] + + +def arithmetic(operation, x1, x2): + """Basic image or object arithmetic for Vistrails image processing + + This function enables basic arithmetic for image processing and data + analysis. The function is capable of applying the basic arithmetic + operations (addition, subtraction, multiplication and division) to two + data set arrays, two constants, or an array and a constant. + + Parameters + ---------- + operation : string + addition: + The addition of EITHER two images or volume data sets, + OR an image/data set and a value. This function is typically + used for offset purposes, or basic recombination of several + isolated materials or phases into a single segmented volume. + subtraction: + Enables the subtraction of EITHER one image or volume data + set from another, OR reduction of all values in an image/data set + by a set value. This function is typically used for offset + purposes, or basic isolation of objects or materials/phases in a + data set. + multiplication: + Enables the multiplication of input 1 (x1) by input 2 (x2). The + inputs can be of any valid numpy data type (e.g. an image or + volume data a fixed, constant, value). This function is typically + used for offset purposes (rescaling), or for assigning values in + the generation of a labelfield identifying objects or + materials/phases in a data set. + + division: + Enables the division of input 1 (x1, numerator) by input 2 (x2, + denominator). The inputs can be of any valid numpy data type + (e.g. an image or volume data a fixed, constant, value). Basic + tests are included in the division function which test for, + and ensure that division by zero does not occur. This function is + typically used for offset purposes (rescaling, normalization). + + x1, x2 : {ndarray, int, float} + Specifies the input data sets, or constants, to be offset or + manipulated + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or constant to the designated variable + + Example + ------- + >>> x1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) + >>> x2 = np.array([[2, 0, 2], [0, 2, 0], [2, 0, 2]]) + >>> arithmetic('addition', x1, x2) + array([[2, 1, 2], + [1, 3, 1], + [2, 1, 2]]) + """ + operation_dict = {'addition' : add, + 'subtraction' : subtract, + 'multiplication' : multiply, + 'division' : divide + } + if operation == 'division': + if type(x2) is np.ndarray: + if 0 in x2: + raise ValueError("This division operation will result in " + "division by zero values. Please reevaluate " + "denominator (x2).") + else: + if float(x2) == 0: + raise ValueError("This division operation will result in " + "division by a zero value. Please " + "reevaluate the denominator constant" + " (x2).") + + return operation_dict[operation](x1, x2) + + +def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, + G=None, H=None): + """Arithmetic tool for VisTrails enabling use of custom expressions + + This function enables more complex arithmetic to be carried out on 2 or + more (current limit is 8) arrays or constants. The arithmetic expression + is defined by the user, as a string, and after assignment of inputs A + through H the string is parsed into the appropriate python expression + and executed. Note that inputs C through H are optional and need only be + defined when desired or required. + + + Parameters + ---------- + expression : string + Note that the syntax of the mathematical expression must conform to + python syntax, + eg.: + using * for multiplication instead of x + using ** for exponents instead of ^ + + Arithmetic operators: + + : addition (adds values on either side of the operator + - : subtraction (subtracts values on either side of the operator + * : multiplication (multiplies values on either side of the + operator + / : division (divides the left operand (numerator) by the right + hand operand (denominator)) + % : modulus (divides the left operand (numerator) by the right + hand operand (denominator) and returns the remainder) + ** : exponent (left operand (base) is raised to the power of the + right operand (exponent)) + // : floor division (divides the left operand (numerator) by the + right hand operand (denominator), but returns the quotient + with any digits after the decimal point removed, + e.g. 9.0/2.0 = 4.0) + + Logical operations are also included and available so long as the: + > : greater than + < : less than + == : exactly equals + != : not equal + >= : greater than or equal + <= : less than or equal + + In the event that bitwise operations are required the operators &, + |, ^, ~ may also be used, though I'm struggling to come up with a + scenario where this will be used. + + Order of operations and parenthesis are taken into account when + evaluating the expression. + + A, B : {ndarray, int, float} + Data set or constant to be offset or manipulated + + C, D, E, F, G, H : {ndarray, int, float}, optional + Optional input ports for data sets or constants to be offset or + manipulated using complex, custom, expressions + + + Returns + ------- + output : {ndarray, int, float} + Returns the resulting array or value to the designated variable + + Example + ------- + >>> A = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) + >>> B = np.array([[2, 0, 2], [0, 2, 0], [2, 0, 2]]) + >>> C = 4 + >>> D = 1.3 + >>> arithmetic_expression('(A+C)/(B+D)', A, B, C, D) + array([[ 1.21212121, 3.84615385, 1.21212121], + [ 3.84615385, 1.51515152, 3.84615385], + [ 1.21212121, 3.84615385, 1.21212121]]) + """ + return eval(parser.expr(expression).compile()) + + +def logic(operation, x1, x2=None): + """VisTrails tool for performing logical operations on image data + + This function enables the computation of the basic logical operations + oft used in image processing of two image or volume data sets. This + function can be used for data comparison, material isolation, + noise removal, or mask application/generation. + + Parameters + ---------- + operation : str + options include: + 'and' -- 2 inputs + 'or' -- 2 inputs + 'not' -- 1 input + 'xor' -- 2 inputs + 'nand' -- 2 inputs + 'subtract' -- 2 inputs + + x1, x2 : {ndarray, int, float, list, tuple} + Specifies the first reference + + Returns + ------- + output : {ndarray, bool} + Returns the result of the logical operation, which can be an array, + or a simple boolean result. + + Example + ------- + >>> x1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) + >>> logic('not', x1) + array([[ True, False, True], + [False, False, False], + [ True, False, True]], dtype=bool) + """ + logic_dict = {'and' : logical_and, + 'or' : logical_or, + 'not' : logical_not, + 'xor' : logical_xor, + 'nand' : logical_nand, + 'nor' : logical_nor, + 'subtract' : logical_sub + } + return logic_dict[operation](x1, x2) From d51e33f885e4a7f80d2ca3d54b077fa0219bdba2 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 14:18:22 -0400 Subject: [PATCH 23/33] TST: Updated basic arith test function after img_proc name changes --- vttools/tests/test_img_proc.py | 133 ++++++++------------------------- 1 file changed, 33 insertions(+), 100 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 458b4a5..7fc5a99 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -16,24 +16,6 @@ from numpy.testing import assert_equal, assert_raises -#Test Data -test_array_1 = np.zeros((30,30,30), dtype=int) -test_array_1[0:15, 0:15, 0:15] = 1 -test_array_2 = np.zeros((50, 70, 50), dtype=int) -test_array_2[25:50, 25:50, 25:50] = 87 -test_array_3 = np.zeros((10,10,10), dtype=float) -test_array_4 = np.zeros((100,100,100), dtype=float) -test_array_5 = np.zeros((100,100), dtype=int) -test_array_5[25:75, 25:75] = 254 - -test_1D_array_1 = np.zeros((100), dtype=int) -test_1D_array_2 = np.zeros((10), dtype=int) -test_1D_array_3 = np.zeros((100), dtype=float) - -test_constant_int = 5 -test_constant_flt = 2.0 -test_constant_bool = True - def test_arithmetic_basic(): """ Test function for the image processing function: arithmetic_basic @@ -63,56 +45,31 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_1, test_constant_int) div_check = np.divide(test_array_1, test_constant_int) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_1, test_constant_int), add_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'subtraction'), - sub_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'multiplication'), - mult_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_int, - 'division'), + assert_equal(img.arithmetic(test_array_1, 'subtraction', + test_constant_int), sub_check) + assert_equal(img.arithmetic('multiplication', test_array_1, + test_constant_int), mult_check) + assert_equal(img.arithmetic('division', test_array_1, test_constant_int), div_check) - assert_raises(ValueError, - img.arithmetic_basic, - test_array_1, - test_array_1, - 'division') - assert_raises(ValueError, - img.arithmetic_basic, - test_array_1, - 0, - 'division') + assert_raises(ValueError, img.arithmetic, 'division', test_array_1, + test_array_1) + assert_raises(ValueError, img.arithmetic, 'division', test_array_1, 0) #Int array and int array add_check = test_array_1 + test_array_2 sub_check = np.subtract(test_array_1, test_array_2) mult_check = np.multiply(test_array_1, test_array_2) - div_check = np.divide(test_array_1, test_array_2) - assert_equal(img.arithmetic_basic(test_array_1, - test_array_2, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_1, test_array_2), add_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_array_2, - 'subtraction'), + assert_equal(img.arithmetic('subtraction', test_array_1, test_array_2), sub_check) - assert_equal(img.arithmetic_basic(test_array_1, - test_array_2, - 'multiplication'), + assert_equal(img.arithmetic('multiplication', test_array_1, test_array_2,), mult_check) - assert_raises(ValueError, - img.arithmetic_basic, - test_array_2, - test_array_1, - 'division') + assert_raises(ValueError, img.arithmetic, 'division', test_array_2, + test_array_1) #Float array and float constant add_check = test_array_3 + test_constant_flt @@ -120,65 +77,41 @@ def test_arithmetic_basic(): mult_check = np.multiply(test_array_3, test_constant_flt) div_check = np.divide(test_array_3, test_constant_flt) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_3, test_constant_flt), add_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'subtraction'), - sub_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'multiplication'), - mult_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_flt, - 'division'), + assert_equal(img.arithmetic('substraction', test_array_3, + test_constant_flt), sub_check) + assert_equal(img.arithmetic('multiplication', test_array_3, + test_constant_flt), mult_check) + assert_equal(img.arithmetic('division', test_array_3, test_constant_flt), div_check) + #Float array and float array add_check = test_array_3 + test_array_3 sub_check = np.subtract(test_array_3, test_array_3) mult_check = np.multiply(test_array_3, test_array_3) div_check = np.divide(test_array_3, test_array_3) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'addition'), + assert_equal(img.arithmetic('addition', test_array_3, test_array_3), add_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'subtraction'), + assert_equal(img.arithmetic('subtraction', test_array_3, test_array_3,), sub_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'multiplication'), + assert_equal(img.arithmetic('multiplication', test_array_3, test_array_3), mult_check) - assert_equal(img.arithmetic_basic(test_array_3, - test_array_3, - 'division'), + assert_equal(img.arithmetic('division', test_array_3, test_array_3), div_check) #Mixed dtypes: Int array and float array - assert_equal(img.arithmetic_basic(test_array_1, - test_array_1.astype(float), - 'addition').dtype, - float) + assert_equal(img.arithmetic('addition', test_array_1, + test_array_1.astype(float)).dtype, float) #Float array and int constant - assert_equal(img.arithmetic_basic(test_array_3, - test_constant_int, - 'addition').dtype, - float) + assert_equal(img.arithmetic('addition', test_array_3, + test_constant_int).dtype, float) #Int array and float constant - assert_equal(img.arithmetic_basic(test_array_1, - test_constant_flt, - 'addition').dtype, - float) + assert_equal(img.arithmetic('addition', test_array_1, + test_constant_flt).dtype, float) #Mismatched array sizes - assert_raises(ValueError, - img.arithmetic_basic, - test_array_1, - test_array_3, - 'addition') + assert_raises(ValueError, img.arithmetic, 'addition', test_array_1, + test_array_3) def test_arithmetic_custom(): From bef01aa13bd8053955494a8514a94851f8ec2cbf Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 14:25:20 -0400 Subject: [PATCH 24/33] TST: Updated test for arith_expression after func name change in vttools --- vttools/tests/test_img_proc.py | 67 ++++++++++++++-------------------- 1 file changed, 27 insertions(+), 40 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 7fc5a99..09228c1 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -116,10 +116,10 @@ def test_arithmetic_basic(): def test_arithmetic_custom(): """ - Test function for mathops.arithmetic_custom, a function that allows the - inclusion of up to 8 inputs (arrays or constants) and application of a - custom expression, to simplify image arithmetic including 2 or more - objects or parameters. + Test function for vttools.to_wrap.image_proc.arithmetic_expression, + a function that allows the inclusion of up to 8 inputs (arrays or + constants) and application of a custom expression, to simplify image + arithmetic including 2 or more objects or parameters. """ #TEST DATA test_array_1 = np.zeros((90,90,90), dtype=int) @@ -143,50 +143,37 @@ def test_arithmetic_custom(): #-int only result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + test_array_5 + test_array_6 + test_array_7 + test_array_8) - assert_equal(img.arithmetic_custom('A+B+C+D+E+F+G+H', - test_array_1, - test_array_2, - test_array_3, - test_array_4, - test_array_5, - test_array_6, - test_array_7, - test_array_8), - result) + + assert_equal(img.arithmetic_expression('A+B+C+D+E+F+G+H', test_array_1, + test_array_2, test_array_3, + test_array_4, test_array_5, + test_array_6, test_array_7, + test_array_8), result) + #-float only result = ((test_array_1.astype(float) + 3.5) + (test_array_3.astype(float) / 2.0) - - test_array_4.astype(float) - ) - assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', - test_array_1.astype(float), - 3.5, - test_array_3.astype(float), - 2.0, - test_array_4.astype(float)), - result) + test_array_4.astype(float)) + + assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', + test_array_1.astype(float), 3.5, + test_array_3.astype(float), 2.0, + test_array_4.astype(float)), result) + #-mixed int and float - result = ((test_array_1 + 3.5) + - (test_array_3.astype(float) / 2) - - test_array_4 - ) - assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', - test_array_1, - 3.5, - test_array_3.astype(float), - 2, - test_array_4.astype(float)), - result) - assert_equal(img.arithmetic_custom('(A+B)+(C/D)-E', - test_array_1, - 3.5, - test_array_3.astype(float), - 2, + result = ((test_array_1 + 3.5) + (test_array_3.astype(float) / 2) - + test_array_4) + + assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', test_array_1, 3.5, + test_array_3.astype(float), 2, + test_array_4.astype(float)), result) + + assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', test_array_1, 3.5, + test_array_3.astype(float), 2, test_array_4.astype(float)).dtype, float) - def test_logic(): """ Test function for mathops.logic_basic, a function that allows for From ffa4cd21b14ea6f2de0703785f27583801b8b71c Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 15:29:27 -0400 Subject: [PATCH 25/33] DOC: Updated input params docstrings, simplifying them. --- vttools/to_wrap/image_proc.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 0ecf75f..3472dd4 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -51,14 +51,14 @@ def arithmetic(operation, x1, x2): and ensure that division by zero does not occur. This function is typically used for offset purposes (rescaling, normalization). - x1, x2 : {ndarray, int, float} + x1, x2 : array_like Specifies the input data sets, or constants, to be offset or manipulated Returns ------- - output : {ndarray, int, float} + output : array_like Returns the resulting array or constant to the designated variable Example @@ -91,6 +91,7 @@ def arithmetic(operation, x1, x2): return operation_dict[operation](x1, x2) + def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, G=None, H=None): """Arithmetic tool for VisTrails enabling use of custom expressions @@ -189,7 +190,7 @@ def logic(operation, x1, x2=None): 'nand' -- 2 inputs 'subtract' -- 2 inputs - x1, x2 : {ndarray, int, float, list, tuple} + x1, x2 : array_like Specifies the first reference Returns From 69e81a05c90108f4f693488987a8e97d80a6ed1d Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 14 Apr 2015 15:30:30 -0400 Subject: [PATCH 26/33] TST: Tested and verified img_proc tst funcs using nose, coverage. --- vttools/tests/test_img_proc.py | 100 +++++++++++++-------------------- 1 file changed, 38 insertions(+), 62 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 09228c1..8080278 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -25,7 +25,7 @@ def test_arithmetic_basic(): test_array_1[0:15, 0:15, 0:15] = 1 test_array_2 = np.zeros((30, 30, 30), dtype=int) test_array_2[15:29, 15:29, 15:29] = 87 - test_array_3 = np.ones((30,30,30), dtype=float) + test_array_3 = np.ones((40,30,30), dtype=float) test_array_3[10:20, 10:20, 10:20] = 87.4 test_array_4 = np.zeros((30,30), dtype=int) test_array_4[24:29, 24:29] = 254 @@ -47,7 +47,7 @@ def test_arithmetic_basic(): assert_equal(img.arithmetic('addition', test_array_1, test_constant_int), add_check) - assert_equal(img.arithmetic(test_array_1, 'subtraction', + assert_equal(img.arithmetic('subtraction', test_array_1, test_constant_int), sub_check) assert_equal(img.arithmetic('multiplication', test_array_1, test_constant_int), mult_check) @@ -79,7 +79,7 @@ def test_arithmetic_basic(): assert_equal(img.arithmetic('addition', test_array_3, test_constant_flt), add_check) - assert_equal(img.arithmetic('substraction', test_array_3, + assert_equal(img.arithmetic('subtraction', test_array_3, test_constant_flt), sub_check) assert_equal(img.arithmetic('multiplication', test_array_3, test_constant_flt), mult_check) @@ -192,89 +192,65 @@ def test_logic(): test_array_3[40:89, 40:89, 40:89] = 3 #and - assert_equal(img.logic_basic('and', test_array_1, test_array_1), - test_array_1) + assert_equal(img.logic('and', test_array_1, test_array_1), test_array_1) - test_result = img.logic_basic('and', test_array_1, test_array_2) + test_result = img.logic('and', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], True) assert_equal(test_result.sum(), ((39-20)**3)) - test_result = img.logic_basic('and', test_array_1, test_array_3) - assert_equal(test_result, False) + assert_equal(img.logic('and', test_array_1, test_array_3), False) #or - assert_equal(img.logic_basic('or', test_array_1, test_array_1), - test_array_1) - - assert_equal(img.logic_basic('or', - test_array_1, - test_array_2).sum(), - (test_array_1.sum() + - test_array_2.sum() / - 2 - - np.logical_and(test_array_1, - test_array_2).sum() - ) - ) - test_result = img.logic_basic('or', test_array_1, test_array_3) - assert_equal(test_result.sum(), - (test_array_1.sum() + - test_array_3.sum() / - test_array_3.max() - ) - ) + assert_equal(img.logic('or', test_array_1, test_array_1), test_array_1) + + assert_equal(img.logic('or', test_array_1, test_array_2).sum(), + (test_array_1.sum() + test_array_2.sum() / 2 - + np.logical_and(test_array_1, test_array_2).sum())) + + test_result = img.logic('or', test_array_1, test_array_3) + assert_equal(test_result.sum(), (test_array_1.sum() + test_array_3.sum() / + test_array_3.max())) #not - assert_equal(img.logic_basic('not', test_array_1).sum(), + assert_equal(img.logic('not', test_array_1).sum(), (90**3-test_array_1.sum())) - assert_equal(img.logic_basic('not', test_array_3).sum(), + + assert_equal(img.logic('not', test_array_3).sum(), (90**3-(test_array_3.sum()/test_array_3.max()))) #xor - assert_equal(img.logic_basic('xor', test_array_1, test_array_1), + assert_equal(img.logic('xor', test_array_1, test_array_1), np.zeros((90,90,90), dtype=int)) - assert_equal(img.logic_basic('xor', - test_array_1, - test_array_2).sum(), - ((test_array_1.sum() + - test_array_2.sum() / 2) - - (2 * np.logical_and(test_array_1, - test_array_2).sum() - ) - ) - ) + + assert_equal(img.logic('xor', test_array_1, test_array_2).sum(), + ((test_array_1.sum() + test_array_2.sum() / 2) - + (2 * np.logical_and(test_array_1, test_array_2).sum()))) #nand - assert_equal(img.logic_basic('nand', test_array_1, test_array_1), + assert_equal(img.logic('nand', test_array_1, test_array_1), np.logical_not(test_array_1)) - test_result = img.logic_basic('nand', test_array_1, test_array_2) + + test_result = img.logic('nand', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) #nor - assert_equal(img.logic_basic('nor', test_array_1, test_array_1), + assert_equal(img.logic('nor', test_array_1, test_array_1), np.logical_not(test_array_1)) - assert_equal(img.logic_basic('nor', - test_array_1, - test_array_2).sum(), + assert_equal(img.logic('nor', test_array_1, test_array_2).sum(), (np.ones((90,90,90), dtype=int).sum() - - (np.logical_or(test_array_1, - test_array_2).sum() - ) - ) - ) + (np.logical_or(test_array_1, test_array_2).sum()))) #subtract - assert_equal(img.logic_basic('subtract', test_array_1, test_array_1), - False) - test_result = img.logic_basic('subtract', test_array_1, test_array_2) + assert_equal(img.logic('subtract', test_array_1, test_array_1), False) + + test_result = img.logic('subtract', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) - assert_equal(test_result.sum(), - (test_array_1.sum() - - np.logical_and(test_array_1, - test_array_2).sum() - ) - ) - test_result = img.logic_basic('subtract', test_array_1, test_array_3) + + assert_equal(test_result.sum(), (test_array_1.sum() - + np.logical_and(test_array_1, + test_array_2).sum())) + + test_result = img.logic('subtract', test_array_1, test_array_3) assert_equal(test_result, test_array_1) From 25fc89cdf958f08ba98e5fa85e9029951805dd71 Mon Sep 17 00:00:00 2001 From: Eric Dill Date: Wed, 15 Apr 2015 01:43:43 -0400 Subject: [PATCH 27/33] DOC, MNT: Edits to be consistent with np and pep8 - This looks like a lot of changes, but there is functionally no difference between the original code and this code. It is entirely stylistic. - Doc edits moved the descriptive prose to `/doc/resource/user-guide/image.rst` and used language largely copied from numpy - content edits favored use of built in functionality over defining look-up dictionaries --- .gitignore | 3 + doc/resource/user-guide/image.rst | 48 ++++++ vttools/tests/test_img_proc.py | 209 ++++++++++++------------ vttools/to_wrap/image_proc.py | 253 ++++++++++++++++++------------ 4 files changed, 312 insertions(+), 201 deletions(-) create mode 100644 doc/resource/user-guide/image.rst diff --git a/.gitignore b/.gitignore index 643044a..7d3311d 100644 --- a/.gitignore +++ b/.gitignore @@ -62,3 +62,6 @@ docs/_build/ # coverage cover/ + +# generated by various tools +html/ diff --git a/doc/resource/user-guide/image.rst b/doc/resource/user-guide/image.rst new file mode 100644 index 0000000..d24b19a --- /dev/null +++ b/doc/resource/user-guide/image.rst @@ -0,0 +1,48 @@ +Image Operations in VisTrails +----------------------------- + +"arithmetic" VisTrails module +============================= +The VisTrails module `arithmetic` enables basic arithmetic for image processing +and data analysis. The function is capable of applying the basic arithmetic +operations (addition, subtraction, multiplication and division) to two data set +arrays, two constants, or an array and a constant. + +**Addition.** The addition of EITHER two images or volume data sets, OR an +image/data set and a value. This function is typically used for offset purposes, +or basic recombination of several isolated materials or phases into a single +segmented volume. + +**Subtraction.** Enables the subtraction of EITHER one image or volume data set +from another, OR reduction of all values in an image/data set by a set value. +This function is typically used for offset purposes, or basic isolation of +objects or materials/phases in a data set. + +**Multiplication.** Enables the multiplication of input 1 (x1) by input 2 (x2). +The inputs can be of any valid numpy data type (e.g. an image or volume data a +fixed, constant, value). This function is typically used for offset purposes +(rescaling), or for assigning values in the generation of a labelfield identifying +objects or materials/phases in a data set. + +**Division.** Enables the division of input 1 (x1, numerator) by input 2 (x2, +denominator). The inputs can be of any valid numpy data type (e.g. an image or +volume data a fixed, constant, value). Basic tests are included in the division +function which test for, and ensure that division by zero does not occur. This +function is typically used for offset purposes (rescaling, normalization). + +"arithmetic_expression" VisTrails module +======================================== +The VisTrails module `arithmetic_expression` enables the use of custom +expressions to evaluate up to 8 input variables, named A-H. This function +enables more complex arithmetic to be carried out on 2 or more (current limit +is 8) arrays or constants. The arithmetic expression is defined by the user, as +a string, and after assignment of inputs A through H the string is parsed into +the appropriate python expression and executed. Note that inputs C through H +are optional and need only be defined when desired or required. + +"logical" VisTrails module +========================== +The VisTrails module `logical` enables the computation of the basic logical +operations oft used in image processing of two image or volume data sets. This +function can be used for data comparison, material isolation, noise removal, +or mask application/generation. diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 8080278..357408a 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -5,7 +5,7 @@ This module contains test functions for the file-IO functions for reading and writing data sets using the netCDF file format. -The files read and written using this function are assumed to +The files read and written using this function are assumed to conform to the format specified for x-ray computed microtomorgraphy data collected at Argonne National Laboratory, Sector 13, GSECars. """ @@ -13,7 +13,20 @@ import numpy as np import six import vttools.to_wrap.image_proc as img -from numpy.testing import assert_equal, assert_raises +from numpy.testing import assert_equal, assert_raises, raises + + +@raises(AttributeError) +def arithmetic_helper_fails(op, x1, x2): + img.arithmetic(op, x1, x2) + + +def test_arithmetic_fails(): + ops = ['addition', 'subtraction', 'division', 'multiplication'] + x1s = [0] * len(ops) + x2s = [0] * len(ops) + for op, x1, x2 in zip(ops, x1s, x2s): + yield arithmetic_helper_fails, op, x1, x2 def test_arithmetic_basic(): @@ -21,96 +34,96 @@ def test_arithmetic_basic(): Test function for the image processing function: arithmetic_basic """ - test_array_1 = np.zeros((30,30,30), dtype=int) + test_array_1 = np.zeros((30, 30, 30), dtype=np.int) test_array_1[0:15, 0:15, 0:15] = 1 - test_array_2 = np.zeros((30, 30, 30), dtype=int) + test_array_2 = np.zeros((30, 30, 30), dtype=np.int) test_array_2[15:29, 15:29, 15:29] = 87 - test_array_3 = np.ones((40,30,30), dtype=float) + test_array_3 = np.ones((40, 30, 30), dtype='float') test_array_3[10:20, 10:20, 10:20] = 87.4 - test_array_4 = np.zeros((30,30), dtype=int) + test_array_4 = np.zeros((30, 30), dtype=np.int) test_array_4[24:29, 24:29] = 254 - test_1D_array_1 = np.zeros((100), dtype=int) - test_1D_array_1[0:30]=50 - test_1D_array_2 = np.zeros((50), dtype=int) - test_1D_array_2[20:49]=10 - test_1D_array_3 = np.ones((100), dtype=float) + test_1D_array_1 = np.zeros(100, dtype=np.int) + test_1D_array_1[0:30] = 50 + test_1D_array_2 = np.zeros(50, dtype=np.int) + test_1D_array_2[20:49] = 10 + test_1D_array_3 = np.ones(10, dtype='float') test_constant_int = 5 test_constant_flt = 2.0 - #Int array and int constant + # Int array and int constant add_check = test_array_1 + test_constant_int sub_check = np.subtract(test_array_1, test_constant_int) mult_check = np.multiply(test_array_1, test_constant_int) div_check = np.divide(test_array_1, test_constant_int) - assert_equal(img.arithmetic('addition', test_array_1, test_constant_int), + assert_equal(img.arithmetic('add', test_array_1, test_constant_int), add_check) - assert_equal(img.arithmetic('subtraction', test_array_1, + assert_equal(img.arithmetic('subtract', test_array_1, test_constant_int), sub_check) - assert_equal(img.arithmetic('multiplication', test_array_1, + assert_equal(img.arithmetic('multiply', test_array_1, test_constant_int), mult_check) - assert_equal(img.arithmetic('division', test_array_1, test_constant_int), + assert_equal(img.arithmetic('divide', test_array_1, test_constant_int), div_check) - assert_raises(ValueError, img.arithmetic, 'division', test_array_1, + assert_raises(FloatingPointError, img.arithmetic, 'divide', test_array_1, test_array_1) - assert_raises(ValueError, img.arithmetic, 'division', test_array_1, 0) + assert_raises(FloatingPointError, img.arithmetic, 'divide', test_array_1, 0) - #Int array and int array + # Int array and int array add_check = test_array_1 + test_array_2 sub_check = np.subtract(test_array_1, test_array_2) mult_check = np.multiply(test_array_1, test_array_2) - assert_equal(img.arithmetic('addition', test_array_1, test_array_2), + assert_equal(img.arithmetic('add', test_array_1, test_array_2), add_check) - assert_equal(img.arithmetic('subtraction', test_array_1, test_array_2), + assert_equal(img.arithmetic('subtract', test_array_1, test_array_2), sub_check) - assert_equal(img.arithmetic('multiplication', test_array_1, test_array_2,), + assert_equal(img.arithmetic('multiply', test_array_1, test_array_2,), mult_check) - assert_raises(ValueError, img.arithmetic, 'division', test_array_2, + assert_raises(FloatingPointError, img.arithmetic, 'divide', test_array_2, test_array_1) - #Float array and float constant + # Float array and float constant add_check = test_array_3 + test_constant_flt sub_check = np.subtract(test_array_3, test_constant_flt) mult_check = np.multiply(test_array_3, test_constant_flt) div_check = np.divide(test_array_3, test_constant_flt) - assert_equal(img.arithmetic('addition', test_array_3, test_constant_flt), + assert_equal(img.arithmetic('add', test_array_3, test_constant_flt), add_check) - assert_equal(img.arithmetic('subtraction', test_array_3, + assert_equal(img.arithmetic('subtract', test_array_3, test_constant_flt), sub_check) - assert_equal(img.arithmetic('multiplication', test_array_3, + assert_equal(img.arithmetic('multiply', test_array_3, test_constant_flt), mult_check) - assert_equal(img.arithmetic('division', test_array_3, test_constant_flt), + assert_equal(img.arithmetic('divide', test_array_3, test_constant_flt), div_check) - #Float array and float array + # Float array and float array add_check = test_array_3 + test_array_3 sub_check = np.subtract(test_array_3, test_array_3) mult_check = np.multiply(test_array_3, test_array_3) div_check = np.divide(test_array_3, test_array_3) - assert_equal(img.arithmetic('addition', test_array_3, test_array_3), + assert_equal(img.arithmetic('add', test_array_3, test_array_3), add_check) - assert_equal(img.arithmetic('subtraction', test_array_3, test_array_3,), + assert_equal(img.arithmetic('subtract', test_array_3, test_array_3,), sub_check) - assert_equal(img.arithmetic('multiplication', test_array_3, test_array_3), + assert_equal(img.arithmetic('multiply', test_array_3, test_array_3), mult_check) - assert_equal(img.arithmetic('division', test_array_3, test_array_3), + assert_equal(img.arithmetic('divide', test_array_3, test_array_3), div_check) - #Mixed dtypes: Int array and float array - assert_equal(img.arithmetic('addition', test_array_1, - test_array_1.astype(float)).dtype, float) - #Float array and int constant - assert_equal(img.arithmetic('addition', test_array_3, + # Mixed dtypes: Int array and float array + assert_equal(img.arithmetic('add', test_array_1, + test_array_1.astype('float')).dtype, float) + # Float array and int constant + assert_equal(img.arithmetic('add', test_array_3, test_constant_int).dtype, float) - #Int array and float constant - assert_equal(img.arithmetic('addition', test_array_1, + # Int array and float constant + assert_equal(img.arithmetic('add', test_array_1, test_constant_flt).dtype, float) - #Mismatched array sizes - assert_raises(ValueError, img.arithmetic, 'addition', test_array_1, + # Mismatched array sizes + assert_raises(ValueError, img.arithmetic, 'add', test_array_1, test_array_3) @@ -121,26 +134,26 @@ def test_arithmetic_custom(): constants) and application of a custom expression, to simplify image arithmetic including 2 or more objects or parameters. """ - #TEST DATA - test_array_1 = np.zeros((90,90,90), dtype=int) + # TEST DATA + test_array_1 = np.zeros((90, 90, 90), dtype=np.int) test_array_1[10:19, 10:19, 10:19] = 1 - test_array_2 = np.zeros((90,90,90), dtype=int) + test_array_2 = np.zeros((90, 90, 90), dtype=np.int) test_array_2[20:29, 20:29, 20:29] = 2 - test_array_3 = np.zeros((90,90,90), dtype=int) + test_array_3 = np.zeros((90, 90, 90), dtype=np.int) test_array_3[30:39, 30:39, 30:39] = 3 - test_array_4 = np.zeros((90,90,90), dtype=int) + test_array_4 = np.zeros((90, 90, 90), dtype=np.int) test_array_4[40:49, 40:49, 40:49] = 4 - test_array_5 = np.zeros((90,90,90), dtype=int) + test_array_5 = np.zeros((90, 90, 90), dtype=np.int) test_array_5[50:59, 50:59, 50:59] = 5 - test_array_6 = np.zeros((90,90,90), dtype=int) + test_array_6 = np.zeros((90, 90, 90), dtype=np.int) test_array_6[60:69, 60:69, 60:69] = 6 - test_array_7 = np.zeros((90,90,90), dtype=int) + test_array_7 = np.zeros((90, 90, 90), dtype=np.int) test_array_7[70:79, 70:79, 70:79] = 7 - test_array_8 = np.zeros((90,90,90), dtype=int) + test_array_8 = np.zeros((90, 90, 90), dtype=np.int) test_array_8[80:89, 80:89, 80:89] = 8 - #Array manipulation - #-int only + # Array manipulation + # -int only result = (test_array_1 + test_array_2 + test_array_3 + test_array_4 + test_array_5 + test_array_6 + test_array_7 + test_array_8) @@ -150,31 +163,33 @@ def test_arithmetic_custom(): test_array_6, test_array_7, test_array_8), result) - #-float only - result = ((test_array_1.astype(float) + 3.5) + - (test_array_3.astype(float) / 2.0) - - test_array_4.astype(float)) + # -float only + result = ((test_array_1.astype('float') + 3.5) + + (test_array_3.astype('float') / 2.0) - + test_array_4.astype('float')) assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', - test_array_1.astype(float), 3.5, - test_array_3.astype(float), 2.0, - test_array_4.astype(float)), result) + test_array_1.astype('float'), 3.5, + test_array_3.astype('float'), 2.0, + test_array_4.astype('float')), + result) - #-mixed int and float - result = ((test_array_1 + 3.5) + (test_array_3.astype(float) / 2) - + # -mixed int and float + result = ((test_array_1 + 3.5) + (test_array_3.astype('float') / 2) - test_array_4) assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', test_array_1, 3.5, - test_array_3.astype(float), 2, - test_array_4.astype(float)), result) + test_array_3.astype('float'), 2, + test_array_4.astype('float')), + result) assert_equal(img.arithmetic_expression('(A+B)+(C/D)-E', test_array_1, 3.5, - test_array_3.astype(float), 2, - test_array_4.astype(float)).dtype, + test_array_3.astype('float'), 2, + test_array_4.astype('float')).dtype, float) -def test_logic(): +def test_logical(): """ Test function for mathops.logic_basic, a function that allows for logical operations to be performed on one or two arrays or constants @@ -183,74 +198,74 @@ def test_logic(): logical not only takes one object, and returns the inverse, while the other operations provide a comparison of two objects). """ - #TEST DATA - test_array_1 = np.zeros((90,90,90), dtype=int) + # TEST DATA + test_array_1 = np.zeros((90, 90, 90), dtype=np.int) test_array_1[0:39, 0:39, 0:39] = 1 - test_array_2 = np.zeros((90,90,90), dtype=int) + test_array_2 = np.zeros((90, 90, 90), dtype=np.int) test_array_2[20:79, 20:79, 20:79] = 2 - test_array_3 = np.zeros((90,90,90), dtype=int) + test_array_3 = np.zeros((90, 90, 90), dtype=np.int) test_array_3[40:89, 40:89, 40:89] = 3 - #and - assert_equal(img.logic('and', test_array_1, test_array_1), test_array_1) + # and + assert_equal(img.logical('and', test_array_1, test_array_1), test_array_1) - test_result = img.logic('and', test_array_1, test_array_2) + test_result = img.logical('and', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], True) assert_equal(test_result.sum(), ((39-20)**3)) - assert_equal(img.logic('and', test_array_1, test_array_3), False) + assert_equal(img.logical('and', test_array_1, test_array_3), False) - #or - assert_equal(img.logic('or', test_array_1, test_array_1), test_array_1) + # or + assert_equal(img.logical('or', test_array_1, test_array_1), test_array_1) - assert_equal(img.logic('or', test_array_1, test_array_2).sum(), + assert_equal(img.logical('or', test_array_1, test_array_2).sum(), (test_array_1.sum() + test_array_2.sum() / 2 - np.logical_and(test_array_1, test_array_2).sum())) - test_result = img.logic('or', test_array_1, test_array_3) + test_result = img.logical('or', test_array_1, test_array_3) assert_equal(test_result.sum(), (test_array_1.sum() + test_array_3.sum() / test_array_3.max())) - #not - assert_equal(img.logic('not', test_array_1).sum(), + # not + assert_equal(img.logical('not', test_array_1).sum(), (90**3-test_array_1.sum())) - assert_equal(img.logic('not', test_array_3).sum(), + assert_equal(img.logical('not', test_array_3).sum(), (90**3-(test_array_3.sum()/test_array_3.max()))) - #xor - assert_equal(img.logic('xor', test_array_1, test_array_1), - np.zeros((90,90,90), dtype=int)) + # xor + assert_equal(img.logical('xor', test_array_1, test_array_1), + np.zeros((90, 90, 90), dtype=np.int)) - assert_equal(img.logic('xor', test_array_1, test_array_2).sum(), + assert_equal(img.logical('xor', test_array_1, test_array_2).sum(), ((test_array_1.sum() + test_array_2.sum() / 2) - (2 * np.logical_and(test_array_1, test_array_2).sum()))) - #nand - assert_equal(img.logic('nand', test_array_1, test_array_1), + # nand + assert_equal(img.logical('nand', test_array_1, test_array_1), np.logical_not(test_array_1)) - test_result = img.logic('nand', test_array_1, test_array_2) + test_result = img.logical('nand', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) - #nor - assert_equal(img.logic('nor', test_array_1, test_array_1), + # nor + assert_equal(img.logical('nor', test_array_1, test_array_1), np.logical_not(test_array_1)) - assert_equal(img.logic('nor', test_array_1, test_array_2).sum(), - (np.ones((90,90,90), dtype=int).sum() - + assert_equal(img.logical('nor', test_array_1, test_array_2).sum(), + (np.ones((90, 90, 90), dtype=np.int).sum() - (np.logical_or(test_array_1, test_array_2).sum()))) - #subtract - assert_equal(img.logic('subtract', test_array_1, test_array_1), False) + # subtract + assert_equal(img.logical('sub', test_array_1, test_array_1), False) - test_result = img.logic('subtract', test_array_1, test_array_2) + test_result = img.logical('sub', test_array_1, test_array_2) assert_equal(test_result[20:39, 20:39, 20:39], False) assert_equal(test_result.sum(), (test_array_1.sum() - np.logical_and(test_array_1, test_array_2).sum())) - test_result = img.logic('subtract', test_array_1, test_array_3) + test_result = img.logical('sub', test_array_1, test_array_3) assert_equal(test_result, test_array_1) diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_proc.py index 3472dd4..b52b3f1 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_proc.py @@ -9,100 +9,112 @@ import numpy as np import parser from skxray.img_proc.mathops import * +import logging -__all__ = ["arithmetic", "logic", "arithmetic_expression"] +logger = logging.getLogger(__name__) +__all__ = ["arithmetic", "logical", "arithmetic_expression"] -def arithmetic(operation, x1, x2): - """Basic image or object arithmetic for Vistrails image processing - This function enables basic arithmetic for image processing and data - analysis. The function is capable of applying the basic arithmetic - operations (addition, subtraction, multiplication and division) to two - data set arrays, two constants, or an array and a constant. +def arithmetic(operation, x1, x2, div_by_zero='raise', out=None): + """Arithmetic for inputs x1 and x2. result = x1 {+ - / *} x2 + + Wrapper around numpy functions `np.add`, `np.subtract`, `np.divide`, + `np.multiply`. As such, much of this docstring is copied from numpydocs to + preserve the information Parameters ---------- - operation : string - addition: - The addition of EITHER two images or volume data sets, - OR an image/data set and a value. This function is typically - used for offset purposes, or basic recombination of several - isolated materials or phases into a single segmented volume. - subtraction: - Enables the subtraction of EITHER one image or volume data - set from another, OR reduction of all values in an image/data set - by a set value. This function is typically used for offset - purposes, or basic isolation of objects or materials/phases in a - data set. - multiplication: - Enables the multiplication of input 1 (x1) by input 2 (x2). The - inputs can be of any valid numpy data type (e.g. an image or - volume data a fixed, constant, value). This function is typically - used for offset purposes (rescaling), or for assigning values in - the generation of a labelfield identifying objects or - materials/phases in a data set. - - division: - Enables the division of input 1 (x1, numerator) by input 2 (x2, - denominator). The inputs can be of any valid numpy data type - (e.g. an image or volume data a fixed, constant, value). Basic - tests are included in the division function which test for, - and ensure that division by zero does not occur. This function is - typically used for offset purposes (rescaling, normalization). + operation : {"add", "subtract", "multiply", "divide"} + add: + The sum of `x1` and `x2`, element-wise. Returns a scalar if + both `x1` and `x2` are scalars. + Note: Equivalent to `x1` + `x2` in terms of array broadcasting. + subtract: + The difference of `x1` and `x2`, element-wise. Returns a scalar if + both `x1` and `x2` are scalars. + Note: Equivalent to ``x1 - x2`` in terms of array broadcasting. + divide: + The quotient `x1/x2`, element-wise. Returns a scalar if + both `x1` and `x2` are scalars. + Notes: + - Equivalent to `x1` / `x2` in terms of array-broadcasting. + - Behavior on division by zero can be changed using `seterr`. + - When both `x1` and `x2` are of an integer type, `divide` will + return integers and throw away the fractional part. Moreover, + division by zero always yields zero in integer arithmetic. + multiply: + The product of `x1` and `x2`, element-wise. Returns a scalar if + both `x1` and `x2` are scalars. + Note: Equivalent to `x1` * `x2` in terms of array broadcasting. x1, x2 : array_like - Specifies the input data sets, or constants, to be offset or - manipulated + Can be floats or arrays + + div_by_zero : divide : {'ignore', 'warn', 'raise'}, optional + Treatment for division by zero. + out : array, optional + Array into which the output is placed. Its type is preserved and it + must be of the right shape to hold the output. See numpy doc.ufuncs. Returns ------- - output : array_like + output : array-like # use underscores for variable names, hyphens in prose Returns the resulting array or constant to the designated variable Example ------- >>> x1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) >>> x2 = np.array([[2, 0, 2], [0, 2, 0], [2, 0, 2]]) - >>> arithmetic('addition', x1, x2) + >>> arithmetic('add', x1, x2) array([[2, 1, 2], [1, 3, 1], [2, 1, 2]]) + >>> arithmetic('subtract', x1, x2) + array([[-2, 1, -2], + [ 1, -1, 1], + [-2, 1, -2]]) + >>> arithmetic('multiply', x1, x2) + array([[0, 0, 0], + [0, 2, 0], + [0, 0, 0]]) + >>> arithmetic('divide', x1, x2, div_by_zero='raise') + Traceback (most recent call last): + File "", line 1, in + File "/home/edill/dev/python/VTTools/vttools/to_wrap/image_proc.py", + line 109, in arithmetic + return op(x1, x2, out) + FloatingPointError: divide by zero encountered in divide + >>> arithmetic('divide', x1, x2, div_by_zero='warn') + /home/edill/dev/python/VTTools/vttools/to_wrap/image_proc.py:109: + RuntimeWarning: divide by zero encountered in divide + return op(x1, x2, out) + array([[0, 0, 0], + [0, 0, 0], + [0, 0, 0]]) + >>> arithmetic('divide', x1, x2, div_by_zero='ignore') + array([[0, 0, 0], + [0, 0, 0], + [0, 0, 0]]) """ - operation_dict = {'addition' : add, - 'subtraction' : subtract, - 'multiplication' : multiply, - 'division' : divide - } - if operation == 'division': - if type(x2) is np.ndarray: - if 0 in x2: - raise ValueError("This division operation will result in " - "division by zero values. Please reevaluate " - "denominator (x2).") - else: - if float(x2) == 0: - raise ValueError("This division operation will result in " - "division by a zero value. Please " - "reevaluate the denominator constant" - " (x2).") - - return operation_dict[operation](x1, x2) - - - -def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, - G=None, H=None): - """Arithmetic tool for VisTrails enabling use of custom expressions - - This function enables more complex arithmetic to be carried out on 2 or - more (current limit is 8) arrays or constants. The arithmetic expression - is defined by the user, as a string, and after assignment of inputs A - through H the string is parsed into the appropriate python expression - and executed. Note that inputs C through H are optional and need only be - defined when desired or required. + # ensure that inputs are numpy arrays + x1 = np.asarray(x1) + x2 = np.asarray(x2) + # use numpy built-in functionality to handle divide by zero problems + np.seterr(divide=div_by_zero) + # can use this one-liner instead of the mapping dictionary + op = getattr(np, operation) + return op(x1, x2, out) + + +def arithmetic_expression(expression, A, B, + C=None, D=None, E=None, F=None, G=None, H=None): + """Custom expression evaluator for up to 8 inputs A-H + Note that it would probably be a good idea (at some point!) to make use of + the `Interpreter` object in lmfit.asteval as it appears to be a rather + parsing tool. @danielballan can speak to this better than I can Parameters ---------- @@ -171,48 +183,81 @@ def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, return eval(parser.expr(expression).compile()) -def logic(operation, x1, x2=None): - """VisTrails tool for performing logical operations on image data - - This function enables the computation of the basic logical operations - oft used in image processing of two image or volume data sets. This - function can be used for data comparison, material isolation, - noise removal, or mask application/generation. +def logical(operation, x1, x2=None, out=None): + """Boolean logic for inputs x1 and x2 Parameters ---------- - operation : str - options include: - 'and' -- 2 inputs - 'or' -- 2 inputs - 'not' -- 1 input - 'xor' -- 2 inputs - 'nand' -- 2 inputs - 'subtract' -- 2 inputs - - x1, x2 : array_like - Specifies the first reference + operation : {'and', 'or', 'not', 'xor', `nor`, 'nand', 'sub'} + Binary operations: + and: Compute the truth value of x1 AND x2 element-wise. + or: Compute the truth value of x1 OR x2 element-wise. + xor: Compute the truth value of x1 XOR x2, element-wise. + nor: Compute truth value of NOT (x1 OR x2)) element wise. + nand: Computes the truth value of NOT (x1 AND x2) element wise. + sub: Compute truth value of x1 AND (NOT (x1 AND x2)) element + wise. + Unary operations: + not: Compute the truth value of NOT x element-wise. + + x1, x2 : array-like + Input arrays. `x1` and `x2` must be of the same shape. + Note that x2 is optional for Unary operations + + out : array_like + An array to store the output. Must be the same shape as input arrays Returns ------- - output : {ndarray, bool} - Returns the result of the logical operation, which can be an array, - or a simple boolean result. + output : array-like + Boolean result with the same shape as `x1` and `x2` of the logical + operation on corresponding elements of `x1` and `x2`. + + See Also + -------- + - User guide section on "Image Operations" (`/doc/resource/user-guide/image.rst`) + - numpy functions: `np.logical_and`, `np.logical_or` and `np.logical_not`, + `np.logical_xor` + - skxray functions: `skxray.img_proc.mathops.logical_nand`, + `skxray.img_proc.mathops.logical_nor, and + `skxray.img_proc.mathops.logical_sub` Example ------- >>> x1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) - >>> logic('not', x1) - array([[ True, False, True], - [False, False, False], - [ True, False, True]], dtype=bool) + >>> x2 = np.array([[2, 0, 2], [0, 2, 0], [2, 0, 2]]) + >>> logical('and', x1, x2) + array([[False, False, False], + [False, True, False], + [False, False, False]], dtype=bool) + >>> logical('or', x1, x2) + array([[ True, True, True], + [ True, True, True], + [ True, True, True]], dtype=bool) + >>> logical('not', x1, x2) # note that 'not' will ignore x2 + array([[1, 0, 1], + [0, 0, 0], + [1, 0, 1]]) + >>> logical('xor', x1, x2) + array([[ True, True, True], + [ True, True, True], + [ True, True, True]], dtype=bool) + >>> logical('xor', x1, x2) + array([[ True, True, True], + [ True, False, True], + [ True, True, True]], dtype=bool) + >>> logical('nand', x1, x2) + array([[ True, True, True], + [ True, True, True], + [ True, True, True]], dtype=bool) + >>> logical('sub', x1, x2) + array([[False, True, False], + [ True, True, True], + [False, True, False]], dtype=bool) """ - logic_dict = {'and' : logical_and, - 'or' : logical_or, - 'not' : logical_not, - 'xor' : logical_xor, - 'nand' : logical_nand, - 'nor' : logical_nor, - 'subtract' : logical_sub - } - return logic_dict[operation](x1, x2) + # can use this one-liner instead of the mapping dictionary + op = globals()["logical_" + operation] + # special case the unary operations + if operation in {'not'}: + return op(x1, out) + return op(x1, x2, out) From 062059fcaa50d976576283569e1cacc8d04c9d24 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Sun, 21 Jun 2015 06:37:54 -0400 Subject: [PATCH 28/33] DEV: Updated init.py to properly include all img proc arithmetic funcs The tools designed to ease use of math functions in VisTrails are now included in vttools-->to_wrap-->image_processing-->arithmetic since these tools are explicitly designed to simplify the VisTrails user experience. As part of the growing collection of image processing functions included in skxray, the basic image arithmetic functions are compiled in skxray-->image_processing-->arithmetic for completeness. --- vt_config/NSLS-II/init.py | 3 + vttools/to_wrap/image_processing/__init__.py | 36 ++++++++ .../arithmetic.py} | 84 ++++++++++--------- 3 files changed, 85 insertions(+), 38 deletions(-) create mode 100644 vttools/to_wrap/image_processing/__init__.py rename vttools/to_wrap/{image_proc.py => image_processing/arithmetic.py} (75%) diff --git a/vt_config/NSLS-II/init.py b/vt_config/NSLS-II/init.py index 8e19ff3..b1efcd2 100644 --- a/vt_config/NSLS-II/init.py +++ b/vt_config/NSLS-II/init.py @@ -52,6 +52,7 @@ # get modules to import import_dict = load_config() + _black_list = ['who', 'mafromtxt', 'ndfromtxt', 'source', 'info', 'add_newdoc_ufunc', 'frombuffer', 'fromiter', 'frompyfunc', 'getbuffer', @@ -103,6 +104,7 @@ def get_modules(): 'scipy.special', 'scipy.stats', 'skxray.calibration', + 'skxray.image_processing.arithmetic', 'skxray.correlation', 'skxray.core', 'skxray.recip', @@ -111,6 +113,7 @@ def get_modules(): 'skxray.io.save_powder_output', 'skxray.io.gsas_file_reader', 'skxray.api.diffraction', + 'vttools.to_wrap.image_processing.arithmetic', 'vttools.to_wrap.fitting', ] diff --git a/vttools/to_wrap/image_processing/__init__.py b/vttools/to_wrap/image_processing/__init__.py new file mode 100644 index 0000000..0ee4e8c --- /dev/null +++ b/vttools/to_wrap/image_processing/__init__.py @@ -0,0 +1,36 @@ +# ###################################################################### +# Copyright (c) 2014, Brookhaven Science Associates, Brookhaven # +# National Laboratory. All rights reserved. # +# # +# Redistribution and use in source and binary forms, with or without # +# modification, are permitted provided that the following conditions # +# are met: # +# # +# * Redistributions of source code must retain the above copyright # +# notice, this list of conditions and the following disclaimer. # +# # +# * 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. # +# # +# * Neither the name of the Brookhaven Science Associates, Brookhaven # +# National Laboratory 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 OTHERWISE) ARISING # +# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # +# POSSIBILITY OF SUCH DAMAGE. # +######################################################################## +import logging +logger = logging.getLogger(__name__) \ No newline at end of file diff --git a/vttools/to_wrap/image_proc.py b/vttools/to_wrap/image_processing/arithmetic.py similarity index 75% rename from vttools/to_wrap/image_proc.py rename to vttools/to_wrap/image_processing/arithmetic.py index b52b3f1..7caa15d 100644 --- a/vttools/to_wrap/image_proc.py +++ b/vttools/to_wrap/image_processing/arithmetic.py @@ -5,53 +5,59 @@ This module is designed to facilitate image arithmetic and logical operations on image data sets. """ - +from __future__ import (absolute_import, division, print_function, + unicode_literals) import numpy as np import parser -from skxray.img_proc.mathops import * +from skxray.image_processing.arithmetic import (logical_and, logical_nand, + logical_or, logical_nor, + logical_not, logical_xor, + logical_sub, add, subtract, + multiply, divide) import logging logger = logging.getLogger(__name__) + __all__ = ["arithmetic", "logical", "arithmetic_expression"] def arithmetic(operation, x1, x2, div_by_zero='raise', out=None): """Arithmetic for inputs x1 and x2. result = x1 {+ - / *} x2 - Wrapper around numpy functions `np.add`, `np.subtract`, `np.divide`, - `np.multiply`. As such, much of this docstring is copied from numpydocs to + Wrapper around numpy functions 'np.add', 'np.subtract', 'np.divide', + 'np.multiply'. As such, much of this docstring is copied from numpydocs to preserve the information Parameters ---------- operation : {"add", "subtract", "multiply", "divide"} add: - The sum of `x1` and `x2`, element-wise. Returns a scalar if - both `x1` and `x2` are scalars. - Note: Equivalent to `x1` + `x2` in terms of array broadcasting. + The sum of 'x1' and 'x2', element-wise. Returns a scalar if + both 'x1' and 'x2' are scalars. + Note: Equivalent to 'x1' + 'x2' in terms of array broadcasting. subtract: - The difference of `x1` and `x2`, element-wise. Returns a scalar if - both `x1` and `x2` are scalars. - Note: Equivalent to ``x1 - x2`` in terms of array broadcasting. + The difference of 'x1' and 'x2', element-wise. Returns a scalar if + both 'x1' and 'x2' are scalars. + Note: Equivalent to ''x1 - x2'' in terms of array broadcasting. divide: - The quotient `x1/x2`, element-wise. Returns a scalar if - both `x1` and `x2` are scalars. + The quotient 'x1/x2', element-wise. Returns a scalar if + both 'x1' and 'x2' are scalars. Notes: - - Equivalent to `x1` / `x2` in terms of array-broadcasting. - - Behavior on division by zero can be changed using `seterr`. - - When both `x1` and `x2` are of an integer type, `divide` will + - Equivalent to 'x1' / 'x2' in terms of array-broadcasting. + - Behavior on division by zero can be changed using 'seterr'. + - When both 'x1' and 'x2' are of an integer type, 'divide' will return integers and throw away the fractional part. Moreover, division by zero always yields zero in integer arithmetic. multiply: - The product of `x1` and `x2`, element-wise. Returns a scalar if - both `x1` and `x2` are scalars. - Note: Equivalent to `x1` * `x2` in terms of array broadcasting. + The product of 'x1' and 'x2', element-wise. Returns a scalar if + both 'x1' and 'x2' are scalars. + Note: Equivalent to 'x1' * 'x2' in terms of array broadcasting. - x1, x2 : array_like + x1, x2 : array Can be floats or arrays - div_by_zero : divide : {'ignore', 'warn', 'raise'}, optional + div_by_zero : {'ignore', 'warn', 'raise'}, optional Treatment for division by zero. out : array, optional @@ -60,7 +66,7 @@ def arithmetic(operation, x1, x2, div_by_zero='raise', out=None): Returns ------- - output : array-like # use underscores for variable names, hyphens in prose + output : array # use underscores for variable names, hyphens in prose Returns the resulting array or constant to the designated variable Example @@ -82,12 +88,12 @@ def arithmetic(operation, x1, x2, div_by_zero='raise', out=None): >>> arithmetic('divide', x1, x2, div_by_zero='raise') Traceback (most recent call last): File "", line 1, in - File "/home/edill/dev/python/VTTools/vttools/to_wrap/image_proc.py", + File "/home/edill/dev/python/VTTools/vttools/to_wrap/arithmetic.py", line 109, in arithmetic return op(x1, x2, out) FloatingPointError: divide by zero encountered in divide >>> arithmetic('divide', x1, x2, div_by_zero='warn') - /home/edill/dev/python/VTTools/vttools/to_wrap/image_proc.py:109: + /home/edill/dev/python/VTTools/vttools/to_wrap/arithmetic.py:109: RuntimeWarning: divide by zero encountered in divide return op(x1, x2, out) array([[0, 0, 0], @@ -113,12 +119,12 @@ def arithmetic_expression(expression, A, B, """Custom expression evaluator for up to 8 inputs A-H Note that it would probably be a good idea (at some point!) to make use of - the `Interpreter` object in lmfit.asteval as it appears to be a rather + the 'Interpreter' object in lmfit.asteval as it appears to be a rather parsing tool. @danielballan can speak to this better than I can Parameters ---------- - expression : string + expression : str Note that the syntax of the mathematical expression must conform to python syntax, eg.: @@ -188,7 +194,7 @@ def logical(operation, x1, x2=None, out=None): Parameters ---------- - operation : {'and', 'or', 'not', 'xor', `nor`, 'nand', 'sub'} + operation : {'and', 'or', 'not', 'xor', 'nor', 'nand', 'sub'} Binary operations: and: Compute the truth value of x1 AND x2 element-wise. or: Compute the truth value of x1 OR x2 element-wise. @@ -200,27 +206,28 @@ def logical(operation, x1, x2=None, out=None): Unary operations: not: Compute the truth value of NOT x element-wise. - x1, x2 : array-like - Input arrays. `x1` and `x2` must be of the same shape. + x1, x2 : array + Input arrays. 'x1' and 'x2' must be of the same shape. Note that x2 is optional for Unary operations - out : array_like + out : array An array to store the output. Must be the same shape as input arrays Returns ------- - output : array-like - Boolean result with the same shape as `x1` and `x2` of the logical - operation on corresponding elements of `x1` and `x2`. + output : array + Boolean result with the same shape as 'x1' and 'x2' of the logical + operation on corresponding elements of 'x1' and 'x2'. See Also -------- - - User guide section on "Image Operations" (`/doc/resource/user-guide/image.rst`) - - numpy functions: `np.logical_and`, `np.logical_or` and `np.logical_not`, - `np.logical_xor` - - skxray functions: `skxray.img_proc.mathops.logical_nand`, - `skxray.img_proc.mathops.logical_nor, and - `skxray.img_proc.mathops.logical_sub` + - User guide section on "Image Operations" + ('/doc/resource/user-guide/image.rst') + - numpy functions: 'np.logical_and', 'np.logical_or', 'np.logical_not', + and 'np.logical_xor' + - skxray functions: 'skxray.image_processing.arithmetic.logical_nand', + 'skxray.image_processing.arithmetic.logical_nor', and + 'skxray.image_processing.arithmetic.logical_sub' Example ------- @@ -255,6 +262,7 @@ def logical(operation, x1, x2=None, out=None): [ True, True, True], [False, True, False]], dtype=bool) """ + # can use this one-liner instead of the mapping dictionary op = globals()["logical_" + operation] # special case the unary operations From ef51305c33282b68ab6bee91ed326ca2dbde7b40 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Sun, 21 Jun 2015 06:45:26 -0400 Subject: [PATCH 29/33] DEV: Changed test import statement to reflect img_proc to arithmetic refactor. --- vttools/tests/test_img_proc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vttools/tests/test_img_proc.py b/vttools/tests/test_img_proc.py index 357408a..e54944b 100644 --- a/vttools/tests/test_img_proc.py +++ b/vttools/tests/test_img_proc.py @@ -11,10 +11,10 @@ """ import numpy as np -import six -import vttools.to_wrap.image_proc as img from numpy.testing import assert_equal, assert_raises, raises +import vttools.to_wrap.image_processing.arithmetic as img + @raises(AttributeError) def arithmetic_helper_fails(op, x1, x2): From 03eaf66134a06788b09a2c72dc11affa5955002d Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Mon, 22 Jun 2015 14:16:39 -0400 Subject: [PATCH 30/33] FIX: Removed HTML folder which was inadvertently added at some point. HTML folder was accidentally added during a previous commit. This folder has now been removed in order to merge this PR finally. --- html/activity.html | 48 ----- html/arrow-down.gif | Bin 73 -> 0 bytes html/arrow-none.gif | Bin 71 -> 0 bytes html/arrow-up.gif | Bin 73 -> 0 bytes html/authors.html | 40 ---- html/commits_by_author.dat | 150 -------------- html/commits_by_author.plot | 15 -- html/commits_by_author.png | Bin 6659 -> 0 bytes html/commits_by_year.dat | 1 - html/commits_by_year.plot | 11 - html/commits_by_year.png | Bin 2929 -> 0 bytes html/commits_by_year_month.dat | 4 - html/commits_by_year_month.plot | 14 -- html/commits_by_year_month.png | Bin 2655 -> 0 bytes html/day_of_week.dat | 7 - html/day_of_week.plot | 11 - html/day_of_week.png | Bin 3446 -> 0 bytes html/domains.dat | 3 - html/domains.plot | 10 - html/domains.png | Bin 3224 -> 0 bytes html/files.html | 30 --- html/files_by_date.dat | 57 ------ html/files_by_date.plot | 15 -- html/files_by_date.png | Bin 2793 -> 0 bytes html/gitstats.cache | Bin 4601 -> 0 bytes html/gitstats.css | 145 ------------- html/hour_of_day.dat | 24 --- html/hour_of_day.plot | 11 - html/hour_of_day.png | Bin 3114 -> 0 bytes html/index.html | 23 --- html/lines.html | 27 --- html/lines_of_code.dat | 38 ---- html/lines_of_code.plot | 14 -- html/lines_of_code.png | Bin 2957 -> 0 bytes html/lines_of_code_by_author.dat | 150 -------------- html/lines_of_code_by_author.plot | 15 -- html/lines_of_code_by_author.png | Bin 6304 -> 0 bytes html/month_of_year.dat | 12 -- html/month_of_year.plot | 11 - html/month_of_year.png | Bin 2703 -> 0 bytes html/sortable.js | 324 ------------------------------ html/tags.html | 22 -- 42 files changed, 1232 deletions(-) delete mode 100644 html/activity.html delete mode 100644 html/arrow-down.gif delete mode 100644 html/arrow-none.gif delete mode 100644 html/arrow-up.gif delete mode 100644 html/authors.html delete mode 100644 html/commits_by_author.dat delete mode 100644 html/commits_by_author.plot delete mode 100644 html/commits_by_author.png delete mode 100644 html/commits_by_year.dat delete mode 100644 html/commits_by_year.plot delete mode 100644 html/commits_by_year.png delete mode 100644 html/commits_by_year_month.dat delete mode 100644 html/commits_by_year_month.plot delete mode 100644 html/commits_by_year_month.png delete mode 100644 html/day_of_week.dat delete mode 100644 html/day_of_week.plot delete mode 100644 html/day_of_week.png delete mode 100644 html/domains.dat delete mode 100644 html/domains.plot delete mode 100644 html/domains.png delete mode 100644 html/files.html delete mode 100644 html/files_by_date.dat delete mode 100644 html/files_by_date.plot delete mode 100644 html/files_by_date.png delete mode 100644 html/gitstats.cache delete mode 100644 html/gitstats.css delete mode 100644 html/hour_of_day.dat delete mode 100644 html/hour_of_day.plot delete mode 100644 html/hour_of_day.png delete mode 100644 html/index.html delete mode 100644 html/lines.html delete mode 100644 html/lines_of_code.dat delete mode 100644 html/lines_of_code.plot delete mode 100644 html/lines_of_code.png delete mode 100644 html/lines_of_code_by_author.dat delete mode 100644 html/lines_of_code_by_author.plot delete mode 100644 html/lines_of_code_by_author.png delete mode 100644 html/month_of_year.dat delete mode 100644 html/month_of_year.plot delete mode 100644 html/month_of_year.png delete mode 100644 html/sortable.js delete mode 100644 html/tags.html diff --git a/html/activity.html b/html/activity.html deleted file mode 100644 index 20070a5..0000000 --- a/html/activity.html +++ /dev/null @@ -1,48 +0,0 @@ - - - - - GitStats - VTTools - - - - - -

Activity

-
- -
- -

Weekly activity

- -

Last 32 weeks

0
0
0
0
0
0
0
0
0
0
0
17
26
19
3
4
17
25
6
5
18
2
0
7
4
0
0
0
0
0
0
0
3231302928272625242322212019181716151413121110987654321
-

Hour of Day

- - - -
Hour01234567891011121314151617181920212223
Commits100009401651712121015982986154
%0.650.000.000.000.005.882.610.000.653.923.2711.117.847.846.549.805.885.231.315.885.233.929.802.61
Hour of Day -

Day of Week

- -
DayTotal (%)
Mon24 (15.69%)
Tue30 (19.61%)
Wed25 (16.34%)
Thu27 (17.65%)
Fri31 (20.26%)
Sat9 (5.88%)
Sun7 (4.58%)
Day of Week -

Hour of Week

- -
Weekday01234567891011121314151617181920212223
Mon11623121322
Tue94151123121
Wed212124211
Thu111345221232
Fri2116636411
Sat12312
Sun2122
-

Month of Year

- -
MonthCommits (%)
10 (0.00 %)
20 (0.00 %)
30 (0.00 %)
40 (0.00 %)
50 (0.00 %)
60 (0.00 %)
70 (0.00 %)
80 (0.00 %)
965 (42.48 %)
1052 (33.99 %)
1125 (16.34 %)
1211 (7.19 %)
Month of Year -

Commits by year/month

- -
MonthCommitsLines addedLines removed
2014-121113351
2014-11251024488
2014-1052671129
2014-09652533313
Commits by year/month -

Commits by Year

- -
YearCommits (% of all)Lines addedLines removed
2014153 (100.00%)4361981
Commits by Year -

Commits by Timezone

- -
TimezoneCommits
-050036
-0400117
\ No newline at end of file diff --git a/html/arrow-down.gif b/html/arrow-down.gif deleted file mode 100644 index 997f02f6b53ee1f68236c86178f5e06273b7432e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 73 zcmZ?wbhEHb6kyGG6G4(pDc_F49pBV3_t*qXJC?=)1P_h?k<^T Z_nGG6G4(pDc_F49pBV3_t*qXJC?;)1P_p?k<^T X_nGG6G4(pDc_F49pBV3_t*qXJC?=)1P_p?k<^T Z_n - - - - GitStats - VTTools - - - - - -

Authors

-
- -
- -

List of Authors

- -
AuthorCommits (%)+ lines- linesFirst commitLast commitAgeActive days# by commits
Eric Dill62 (40.52%)402312682014-09-092014-12-1192 days, 23:38:08201
Gabriel Iltis41 (26.80%)14049602014-09-182014-10-3041 days, 20:55:14122
Thomas A Caswell27 (17.65%)2721682014-09-092014-12-0789 days, 0:13:52103
Sameera Abeykoon10 (6.54%)45142014-09-292014-10-3031 days, 1:18:3564
licode9 (5.88%)264392014-09-232014-11-1755 days, 0:43:5865
Wei Xu2 (1.31%)332014-12-042014-12-062 days, 8:34:5826
Li Li2 (1.31%)002014-09-232014-11-1452 days, 0:13:5127
-

Cumulated Added Lines of Code per Author

- -Lines of code per Author -

Commits per Author

- -Commits per Author -

Author of Month

- -
MonthAuthorCommits (%)Next top 5Number of authors
2014-12Thomas A Caswell5 (45.45% of 11)Eric Dill, Wei Xu3
2014-11Eric Dill18 (72.00% of 25)licode, Li Li3
2014-10Gabriel Iltis35 (67.31% of 52)Sameera Abeykoon, Thomas A Caswell, Eric Dill, licode5
2014-09Eric Dill38 (58.46% of 65)Thomas A Caswell, Gabriel Iltis, licode, Sameera Abeykoon, Li Li6
-

Author of Year

- -
YearAuthorCommits (%)Next top 5Number of authors
2014Eric Dill62 (40.52% of 153)Gabriel Iltis, Thomas A Caswell, Sameera Abeykoon, licode, Wei Xu7
-

Commits by Domains

- -
DomainsTotal (%)
bnl.gov110 (71.90%)
gmail.com31 (20.26%)
ncsu.edu12 (7.84%)
Commits by Domains \ No newline at end of file diff --git a/html/commits_by_author.dat b/html/commits_by_author.dat deleted file mode 100644 index 8faeadc..0000000 --- a/html/commits_by_author.dat +++ /dev/null @@ -1,150 +0,0 @@ -1410295581 1 0 0 0 0 0 0 -1410295903 2 0 0 0 0 0 0 -1410298005 3 0 0 0 0 0 0 -1410307531 3 0 1 0 0 0 0 -1410309908 4 0 1 0 0 0 0 -1410355340 5 0 1 0 0 0 0 -1410461076 6 0 1 0 0 0 0 -1410471462 7 0 1 0 0 0 0 -1410484387 7 0 2 0 0 0 0 -1410539586 8 0 2 0 0 0 0 -1410539655 9 0 2 0 0 0 0 -1410544965 10 0 2 0 0 0 0 -1410547908 11 0 2 0 0 0 0 -1410548603 12 0 2 0 0 0 0 -1410548944 13 0 2 0 0 0 0 -1410549087 13 0 3 0 0 0 0 -1410665665 14 0 3 0 0 0 0 -1411006353 15 0 3 0 0 0 0 -1411006382 16 0 3 0 0 0 0 -1411006470 17 0 3 0 0 0 0 -1411006512 18 0 3 0 0 0 0 -1411006669 19 0 3 0 0 0 0 -1411007173 20 0 3 0 0 0 0 -1411009106 21 0 3 0 0 0 0 -1411051546 21 0 4 0 0 0 0 -1411055425 22 0 4 0 0 0 0 -1411057176 23 0 4 0 0 0 0 -1411057642 23 0 5 0 0 0 0 -1411076409 23 1 5 0 0 0 0 -1411131939 24 1 5 0 0 0 0 -1411136918 24 1 6 0 0 0 0 -1411143263 25 1 6 0 0 0 0 -1411144306 25 1 7 0 0 0 0 -1411145807 26 1 7 0 0 0 0 -1411145842 27 1 7 0 0 0 0 -1411148715 27 2 7 0 0 0 0 -1411221344 28 2 7 0 0 0 0 -1411222174 29 2 7 0 0 0 0 -1411222943 30 2 7 0 0 0 0 -1411225228 31 2 7 0 0 0 0 -1411225419 32 2 7 0 0 0 0 -1411225924 33 2 7 0 0 0 0 -1411264370 34 2 7 0 0 0 0 -1411400322 35 2 7 0 0 0 0 -1411485597 35 2 7 0 1 0 0 -1411485630 35 2 7 0 1 0 1 -1411487201 36 2 7 0 1 0 1 -1411488438 37 2 7 0 1 0 1 -1411602878 37 2 8 0 1 0 1 -1411602919 37 2 9 0 1 0 1 -1411602974 37 2 10 0 1 0 1 -1411603118 37 2 11 0 1 0 1 -1411603285 37 2 12 0 1 0 1 -1411603414 37 2 13 0 1 0 1 -1411611758 37 2 14 0 1 0 1 -1411611862 37 2 15 0 1 0 1 -1411612232 37 2 16 0 1 0 1 -1411612864 37 2 17 0 1 0 1 -1411758852 38 2 17 0 1 0 1 -1411760051 38 3 17 0 1 0 1 -1411760654 38 4 17 0 1 0 1 -1411790072 38 5 17 0 1 0 1 -1412006449 38 5 17 0 2 0 1 -1412011481 38 5 17 1 2 0 1 -1412025015 38 6 17 1 2 0 1 -1412606172 38 6 17 2 2 0 1 -1412798116 38 6 17 3 2 0 1 -1412861933 38 6 17 4 2 0 1 -1412946301 38 6 18 4 2 0 1 -1413386403 38 7 18 4 2 0 1 -1413487584 38 8 18 4 2 0 1 -1413488272 38 9 18 4 2 0 1 -1413489010 38 10 18 4 2 0 1 -1413491521 38 11 18 4 2 0 1 -1413497889 38 12 18 4 2 0 1 -1413505489 38 13 18 4 2 0 1 -1413507110 38 14 18 4 2 0 1 -1413508745 38 15 18 4 2 0 1 -1413510104 38 16 18 4 2 0 1 -1413511413 38 17 18 4 2 0 1 -1413511794 38 18 18 4 2 0 1 -1413570999 38 19 18 4 2 0 1 -1413577844 39 19 18 4 2 0 1 -1413577966 40 19 18 4 2 0 1 -1413578459 40 20 18 4 2 0 1 -1413579084 40 21 18 4 2 0 1 -1413819476 40 21 18 5 2 0 1 -1413819615 40 21 18 6 2 0 1 -1413820012 40 21 18 7 2 0 1 -1413820140 40 21 18 8 2 0 1 -1413820306 40 21 18 9 2 0 1 -1413831813 40 21 19 9 2 0 1 -1413845407 40 22 19 9 2 0 1 -1413848238 40 23 19 9 2 0 1 -1413849155 40 24 19 9 2 0 1 -1413849503 40 25 19 9 2 0 1 -1413855558 40 26 19 9 2 0 1 -1413855728 40 27 19 9 2 0 1 -1413859749 40 28 19 9 2 0 1 -1413860027 40 29 19 9 2 0 1 -1413904720 40 30 19 9 2 0 1 -1413985972 40 31 19 9 2 0 1 -1414002032 40 32 19 9 2 0 1 -1414002161 40 33 19 9 2 0 1 -1414014852 40 34 19 9 2 0 1 -1414015108 40 35 19 9 2 0 1 -1414170215 40 36 19 9 2 0 1 -1414170594 40 37 19 9 2 0 1 -1414171018 40 38 19 9 2 0 1 -1414171440 40 39 19 9 2 0 1 -1414184835 40 40 19 9 2 0 1 -1414525388 40 40 20 9 2 0 1 -1414525888 40 40 21 9 2 0 1 -1414555083 40 40 22 9 2 0 1 -1414694123 40 41 22 9 2 0 1 -1414694596 40 41 22 10 2 0 1 -1414697598 40 41 22 10 3 0 1 -1415040467 40 41 22 10 4 0 1 -1415108847 41 41 22 10 4 0 1 -1415556923 41 41 22 10 6 0 1 -1415558473 41 41 22 10 7 0 1 -1415656887 42 41 22 10 7 0 1 -1415701333 43 41 22 10 7 0 1 -1415701685 44 41 22 10 7 0 1 -1415701963 45 41 22 10 7 0 1 -1415702031 46 41 22 10 7 0 1 -1415702124 47 41 22 10 7 0 1 -1415702345 48 41 22 10 7 0 1 -1415702482 49 41 22 10 7 0 1 -1415702795 50 41 22 10 7 0 1 -1415703024 51 41 22 10 7 0 1 -1415703740 52 41 22 10 7 0 1 -1415703871 53 41 22 10 7 0 1 -1415704040 54 41 22 10 7 0 1 -1415704198 55 41 22 10 7 0 1 -1415722431 56 41 22 10 7 0 1 -1415899718 57 41 22 10 7 0 1 -1415982861 57 41 22 10 7 0 2 -1415989897 58 41 22 10 7 0 2 -1416201507 58 41 22 10 8 0 2 -1416243835 58 41 22 10 9 0 2 -1417724482 58 41 22 10 9 1 2 -1417928180 58 41 22 10 9 2 2 -1417982156 58 41 23 10 9 2 2 -1418000682 58 41 26 10 9 2 2 -1418001563 58 41 27 10 9 2 2 -1418150502 59 41 27 10 9 2 2 -1418159469 60 41 27 10 9 2 2 -1418326503 61 41 27 10 9 2 2 -1418333069 62 41 27 10 9 2 2 diff --git a/html/commits_by_author.plot b/html/commits_by_author.plot deleted file mode 100644 index a73c4c3..0000000 --- a/html/commits_by_author.plot +++ /dev/null @@ -1,15 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set terminal png transparent size 640,480 -set output 'commits_by_author.png' -set key left top -set yrange [0:] -set xdata time -set timefmt "%s" -set format x "%Y-%m-%d" -set grid y -set ylabel "Commits" -set xtics rotate -set bmargin 6 -plot 'commits_by_author.dat' using 1:2 title "Eric Dill" w lines, 'commits_by_author.dat' using 1:3 title "Gabriel Iltis" w lines, 'commits_by_author.dat' using 1:4 title "Thomas A Caswell" w lines, 'commits_by_author.dat' using 1:5 title "Sameera Abeykoon" w lines, 'commits_by_author.dat' using 1:6 title "licode" w lines, 'commits_by_author.dat' using 1:7 title "Wei Xu" w lines, 'commits_by_author.dat' using 1:8 title "Li Li" w lines diff --git a/html/commits_by_author.png b/html/commits_by_author.png deleted file mode 100644 index 1ac44c28943e6fc352a98a9fdb1951a99c524c4d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6659 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 diff --git a/html/commits_by_year_month.dat b/html/commits_by_year_month.dat deleted file mode 100644 index abea726..0000000 --- a/html/commits_by_year_month.dat +++ /dev/null @@ -1,4 +0,0 @@ -2014-09 65 -2014-10 52 -2014-11 25 -2014-12 11 diff --git a/html/commits_by_year_month.plot b/html/commits_by_year_month.plot deleted file mode 100644 index afb6c09..0000000 --- a/html/commits_by_year_month.plot +++ /dev/null @@ -1,14 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set output 'commits_by_year_month.png' -unset key -set yrange [0:] -set xdata time -set timefmt "%Y-%m" -set format x "%Y-%m" -set xtics rotate -set bmargin 5 -set grid y -set ylabel "Commits" -plot 'commits_by_year_month.dat' using 1:2:(0.5) w boxes fs solid diff --git a/html/commits_by_year_month.png b/html/commits_by_year_month.png deleted file mode 100644 index 912fbdec3a29f605aeadc8ff38858c293d979426..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2655 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 diff --git a/html/files.html b/html/files.html deleted file mode 100644 index e481395..0000000 --- a/html/files.html +++ /dev/null @@ -1,30 +0,0 @@ - - - - - GitStats - VTTools - - - - - -

Files

-
- -
-
-
Total files
27
Total lines
3380
Average file size
4870.04 bytes
- -

File count by date

- -Files by Date -

Extensions

- -
ExtensionFiles (%)Lines (%)Lines/file
3 (11.11%)100 (2.96%)33
md1 (3.70%)1 (0.03%)1
py19 (70.37%)3098 (91.66%)163
sh1 (3.70%)4 (0.12%)4
yaml2 (7.41%)135 (3.99%)67
yml1 (3.70%)36 (1.07%)36
\ No newline at end of file diff --git a/html/files_by_date.dat b/html/files_by_date.dat deleted file mode 100644 index 6e0d813..0000000 --- a/html/files_by_date.dat +++ /dev/null @@ -1,57 +0,0 @@ -2014-09-09 1 -2014-09-09 5 -2014-09-09 6 -2014-09-10 6 -2014-09-11 6 -2014-09-12 6 -2014-09-13 6 -2014-09-17 11 -2014-09-17 6 -2014-09-18 11 -2014-09-19 11 -2014-09-20 15 -2014-09-20 16 -2014-09-20 17 -2014-09-22 17 -2014-09-23 17 -2014-09-24 17 -2014-09-26 17 -2014-09-29 17 -2014-10-06 17 -2014-10-08 17 -2014-10-09 17 -2014-10-10 17 -2014-10-15 18 -2014-10-16 17 -2014-10-16 18 -2014-10-17 17 -2014-10-17 18 -2014-10-20 17 -2014-10-20 18 -2014-10-21 17 -2014-10-22 18 -2014-10-24 17 -2014-10-24 18 -2014-10-28 17 -2014-10-28 18 -2014-10-30 17 -2014-10-30 18 -2014-11-03 18 -2014-11-04 19 -2014-11-09 18 -2014-11-09 19 -2014-11-10 20 -2014-11-11 19 -2014-11-11 21 -2014-11-11 22 -2014-11-11 24 -2014-11-11 25 -2014-11-13 25 -2014-11-14 25 -2014-11-17 25 -2014-12-04 25 -2014-12-06 25 -2014-12-07 25 -2014-12-07 27 -2014-12-09 27 -2014-12-11 27 diff --git a/html/files_by_date.plot b/html/files_by_date.plot deleted file mode 100644 index e5b372a..0000000 --- a/html/files_by_date.plot +++ /dev/null @@ -1,15 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set output 'files_by_date.png' -unset key -set yrange [0:] -set xdata time -set timefmt "%Y-%m-%d" -set format x "%Y-%m-%d" -set grid y -set ylabel "Files" -set xtics rotate -set ytics autofreq -set bmargin 6 -plot 'files_by_date.dat' using 1:2 w steps diff --git a/html/files_by_date.png b/html/files_by_date.png deleted file mode 100644 index d873daf00cc9e8b989e1f1f879f8c89bb9cf3a10..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2793 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 diff --git a/html/gitstats.cache b/html/gitstats.cache deleted file mode 100644 index 75a8fef19c0a896753d934feacfff7a8eb008deb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4601 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 diff --git a/html/gitstats.css b/html/gitstats.css deleted file mode 100644 index d807cb0..0000000 --- a/html/gitstats.css +++ /dev/null @@ -1,145 +0,0 @@ -/** - * GitStats - default style - */ -body { - color: black; - background-color: #dfd; -} - -dt { - font-weight: bold; - float: left; - margin-right: 1em; -} - -dt:after { - content: ': '; -} - -dd { - display: block; - clear: left; -} - -table { - border: 1px solid black; - border-collapse: collapse; - font-size: 80%; - margin-bottom: 1em; -} - -table.noborders { - border: none; -} - -table.noborders td { - border: none; -} - -.vtable { - float: right; - clear: both; -} - -table.tags td { - vertical-align: top; -} - -td { - background-color: white; -} - -th { - background-color: #ddf; -} - -th a { - text-decoration: none; -} - -tr:hover { - background-color: #ddf; -} - -td { - border: 1px solid black; - padding: 0.2em; - padding-left: 0.3em; - padding-right: 0.2em; -} - -/* Navigation bar; tabbed style */ -.nav { - border-bottom: 1px solid black; - padding: 0.3em; -} - -.nav ul { - list-style-type: none; - display: inline; - margin: 0; - padding: 0; -} - -.nav li { - display: inline; -} - -.nav li a { - padding: 0.3em; - text-decoration: none; - color: black; - border: 1px solid black; - margin: 0.5em; - background-color: #ddf; -} - -.nav li a:hover { - background-color: #ddd; - border-bottom: 1px solid #ddf; -} - -img { - border: 1px solid black; - padding: 0.5em; - background-color: white; -} - -th img { - border: 0px; - padding: 0px; - background-color: #ddf; -} - -h1 a, h2 a { - color: black; - text-decoration: none; -} - -h1:hover a:after, -h2:hover a:after { - content: '¶'; - color: #555; -} - -h1 { - font-size: x-large; -} - -h2 { - background-color: #564; - border: 1px solid black; - padding-left: 0.5em; - padding-right: 0.5em; - color: white; - font-size: large; - clear: both; -} - -h2 a { - color: white; -} - -.moreauthors { - font-size: 80%; -} diff --git a/html/hour_of_day.dat b/html/hour_of_day.dat deleted file mode 100644 index 630f59e..0000000 --- a/html/hour_of_day.dat +++ /dev/null @@ -1,24 +0,0 @@ -1 1 -2 0 -3 0 -4 0 -5 0 -6 9 -7 4 -8 0 -9 1 -10 6 -11 5 -12 17 -13 12 -14 12 -15 10 -16 15 -17 9 -18 8 -19 2 -20 9 -21 8 -22 6 -23 15 -24 4 diff --git a/html/hour_of_day.plot b/html/hour_of_day.plot deleted file mode 100644 index 0affd30..0000000 --- a/html/hour_of_day.plot +++ /dev/null @@ -1,11 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set output 'hour_of_day.png' -unset key -set xrange [0.5:24.5] -set yrange [0:] -set xtics 4 -set grid y -set ylabel "Commits" -plot 'hour_of_day.dat' using 1:2:(0.5) w boxes fs solid diff --git a/html/hour_of_day.png b/html/hour_of_day.png deleted file mode 100644 index be70f4fb72ddf7e6bda7c54b676f474d40ab9052..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3114 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 diff --git a/html/index.html b/html/index.html deleted file mode 100644 index fb31173..0000000 --- a/html/index.html +++ /dev/null @@ -1,23 +0,0 @@ - - - - - GitStats - VTTools - - - - - -

GitStats - VTTools

-
- -
-
Project name
VTTools
Generated
2015-01-30 10:43:20 (in 0 seconds)
Generator
GitStats (version a5a9b09), git version 2.1.0, gnuplot 4.6 patchlevel 5
Report Period
2014-09-09 16:46:21 to 2014-12-11 16:24:29
Age
94 days, 40 active days (42.55%)
Total Files
27
Total Lines of Code
3380 (4361 added, 981 removed)
Total Commits
153 (average 3.8 commits per active day, 1.6 per all days)
Authors
7 (average 21.9 commits per author)
- \ No newline at end of file diff --git a/html/lines.html b/html/lines.html deleted file mode 100644 index 6829204..0000000 --- a/html/lines.html +++ /dev/null @@ -1,27 +0,0 @@ - - - - - GitStats - VTTools - - - - - -

Lines

-
- -
-
-
Total lines
3380
- -

Lines of Code

- - \ No newline at end of file diff --git a/html/lines_of_code.dat b/html/lines_of_code.dat deleted file mode 100644 index 0c37ce3..0000000 --- a/html/lines_of_code.dat +++ /dev/null @@ -1,38 +0,0 @@ -1410295581 28 -1410295903 678 -1410298005 773 -1410309908 775 -1410355340 848 -1410461076 844 -1410471462 837 -1410539586 766 -1410539655 766 -1410549087 780 -1411006669 789 -1411051546 1685 -1411057642 1692 -1411136918 1699 -1411144306 1715 -1411145842 1715 -1411148715 1715 -1411485630 2213 -1411487201 2212 -1411488438 2212 -1411758852 2211 -1412011481 2220 -1412946301 2226 -1413577844 2226 -1413577966 2227 -1413831813 2252 -1414525888 2490 -1414555083 2768 -1414694596 2762 -1415701685 2850 -1415702031 2847 -1415982861 3292 -1415989897 3298 -1417982156 3298 -1418150502 3319 -1418159469 3364 -1418326503 3377 -1418333069 3380 diff --git a/html/lines_of_code.plot b/html/lines_of_code.plot deleted file mode 100644 index 7f2088c..0000000 --- a/html/lines_of_code.plot +++ /dev/null @@ -1,14 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set output 'lines_of_code.png' -unset key -set yrange [0:] -set xdata time -set timefmt "%s" -set format x "%Y-%m-%d" -set grid y -set ylabel "Lines" -set xtics rotate -set bmargin 6 -plot 'lines_of_code.dat' using 1:2 w lines diff --git a/html/lines_of_code.png b/html/lines_of_code.png deleted file mode 100644 index 3a02e085164c07bfe74990e987b765651e019f65..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2957 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 SWaP96fQ_Yt#XU3Mgnt7^wO-%= diff --git a/html/lines_of_code_by_author.dat b/html/lines_of_code_by_author.dat deleted file mode 100644 index ff06fca..0000000 --- a/html/lines_of_code_by_author.dat +++ /dev/null @@ -1,150 +0,0 @@ -1410295581 28 0 0 0 0 0 0 -1410295903 685 0 0 0 0 0 0 -1410298005 784 0 0 0 0 0 0 -1410307531 784 0 4 0 0 0 0 -1410309908 784 0 4 0 0 0 0 -1410355340 873 0 4 0 0 0 0 -1410461076 883 0 4 0 0 0 0 -1410471462 909 0 4 0 0 0 0 -1410484387 909 0 4 0 0 0 0 -1410539586 910 0 4 0 0 0 0 -1410539655 910 0 4 0 0 0 0 -1410544965 933 0 4 0 0 0 0 -1410547908 969 0 4 0 0 0 0 -1410548603 972 0 4 0 0 0 0 -1410548944 973 0 4 0 0 0 0 -1410549087 973 0 4 0 0 0 0 -1410665665 985 0 4 0 0 0 0 -1411006353 1912 0 4 0 0 0 0 -1411006382 1913 0 4 0 0 0 0 -1411006470 1914 0 4 0 0 0 0 -1411006512 1954 0 4 0 0 0 0 -1411006669 1954 0 4 0 0 0 0 -1411007173 1958 0 4 0 0 0 0 -1411009106 1967 0 4 0 0 0 0 -1411051546 1967 0 4 0 0 0 0 -1411055425 1990 0 4 0 0 0 0 -1411057176 1991 0 4 0 0 0 0 -1411057642 1991 0 4 0 0 0 0 -1411076409 1991 1 4 0 0 0 0 -1411131939 2005 1 4 0 0 0 0 -1411136918 2005 1 4 0 0 0 0 -1411143263 2021 1 4 0 0 0 0 -1411144306 2021 1 4 0 0 0 0 -1411145807 2022 1 4 0 0 0 0 -1411145842 2022 1 4 0 0 0 0 -1411148715 2022 1 4 0 0 0 0 -1411221344 2275 1 4 0 0 0 0 -1411222174 2342 1 4 0 0 0 0 -1411222943 2354 1 4 0 0 0 0 -1411225228 2501 1 4 0 0 0 0 -1411225419 2505 1 4 0 0 0 0 -1411225924 2508 1 4 0 0 0 0 -1411264370 2726 1 4 0 0 0 0 -1411400322 2730 1 4 0 0 0 0 -1411485597 2730 1 4 0 11 0 0 -1411485630 2730 1 4 0 11 0 0 -1411487201 2730 1 4 0 11 0 0 -1411488438 2731 1 4 0 11 0 0 -1411602878 2731 1 14 0 11 0 0 -1411602919 2731 1 18 0 11 0 0 -1411602974 2731 1 171 0 11 0 0 -1411603118 2731 1 174 0 11 0 0 -1411603285 2731 1 174 0 11 0 0 -1411603414 2731 1 190 0 11 0 0 -1411611758 2731 1 191 0 11 0 0 -1411611862 2731 1 198 0 11 0 0 -1411612232 2731 1 201 0 11 0 0 -1411612864 2731 1 202 0 11 0 0 -1411758852 2732 1 202 0 11 0 0 -1411760051 2732 43 202 0 11 0 0 -1411760654 2732 48 202 0 11 0 0 -1411790072 2732 179 202 0 11 0 0 -1412006449 2732 179 202 0 20 0 0 -1412011481 2732 179 202 0 20 0 0 -1412025015 2732 200 202 0 20 0 0 -1412606172 2732 200 202 1 20 0 0 -1412798116 2732 200 202 7 20 0 0 -1412861933 2732 200 202 8 20 0 0 -1412946301 2732 200 202 8 20 0 0 -1413386403 2732 388 202 8 20 0 0 -1413487584 2732 443 202 8 20 0 0 -1413488272 2732 443 202 8 20 0 0 -1413489010 2732 443 202 8 20 0 0 -1413491521 2732 445 202 8 20 0 0 -1413497889 2732 542 202 8 20 0 0 -1413505489 2732 851 202 8 20 0 0 -1413507110 2732 864 202 8 20 0 0 -1413508745 2732 864 202 8 20 0 0 -1413510104 2732 876 202 8 20 0 0 -1413511413 2732 1088 202 8 20 0 0 -1413511794 2732 1138 202 8 20 0 0 -1413570999 2732 1145 202 8 20 0 0 -1413577844 2736 1145 202 8 20 0 0 -1413577966 2738 1145 202 8 20 0 0 -1413578459 2738 1151 202 8 20 0 0 -1413579084 2738 1152 202 8 20 0 0 -1413819476 2738 1152 202 32 20 0 0 -1413819615 2738 1152 202 32 20 0 0 -1413820012 2738 1152 202 39 20 0 0 -1413820140 2738 1152 202 39 20 0 0 -1413820306 2738 1152 202 45 20 0 0 -1413831813 2738 1152 202 45 20 0 0 -1413845407 2738 1158 202 45 20 0 0 -1413848238 2738 1161 202 45 20 0 0 -1413849155 2738 1168 202 45 20 0 0 -1413849503 2738 1175 202 45 20 0 0 -1413855558 2738 1185 202 45 20 0 0 -1413855728 2738 1275 202 45 20 0 0 -1413859749 2738 1279 202 45 20 0 0 -1413860027 2738 1295 202 45 20 0 0 -1413904720 2738 1305 202 45 20 0 0 -1413985972 2738 1305 202 45 20 0 0 -1414002032 2738 1312 202 45 20 0 0 -1414002161 2738 1329 202 45 20 0 0 -1414014852 2738 1330 202 45 20 0 0 -1414015108 2738 1349 202 45 20 0 0 -1414170215 2738 1385 202 45 20 0 0 -1414170594 2738 1393 202 45 20 0 0 -1414171018 2738 1397 202 45 20 0 0 -1414171440 2738 1399 202 45 20 0 0 -1414184835 2738 1400 202 45 20 0 0 -1414525388 2738 1400 211 45 20 0 0 -1414525888 2738 1400 211 45 20 0 0 -1414555083 2738 1400 211 45 20 0 0 -1414694123 2738 1404 211 45 20 0 0 -1414694596 2738 1404 211 45 20 0 0 -1414697598 2738 1404 211 45 33 0 0 -1415040467 2738 1404 211 45 115 0 0 -1415108847 2811 1404 211 45 115 0 0 -1415556923 2811 1404 211 45 209 0 0 -1415558473 2811 1404 211 45 209 0 0 -1415656887 3135 1404 211 45 209 0 0 -1415701333 3894 1404 211 45 209 0 0 -1415701685 3894 1404 211 45 209 0 0 -1415701963 3894 1404 211 45 209 0 0 -1415702031 3894 1404 211 45 209 0 0 -1415702124 3894 1404 211 45 209 0 0 -1415702345 3931 1404 211 45 209 0 0 -1415702482 3933 1404 211 45 209 0 0 -1415702795 3938 1404 211 45 209 0 0 -1415703024 3939 1404 211 45 209 0 0 -1415703740 3942 1404 211 45 209 0 0 -1415703871 3944 1404 211 45 209 0 0 -1415704040 3945 1404 211 45 209 0 0 -1415704198 3949 1404 211 45 209 0 0 -1415722431 3949 1404 211 45 209 0 0 -1415899718 3989 1404 211 45 209 0 0 -1415982861 3989 1404 211 45 209 0 0 -1415989897 4005 1404 211 45 209 0 0 -1416201507 4005 1404 211 45 232 0 0 -1416243835 4005 1404 211 45 264 0 0 -1417724482 4005 1404 211 45 264 2 0 -1417928180 4005 1404 211 45 264 3 0 -1417982156 4005 1404 211 45 264 3 0 -1418000682 4005 1404 253 45 264 3 0 -1418001563 4005 1404 272 45 264 3 0 -1418150502 4005 1404 272 45 264 3 0 -1418159469 4005 1404 272 45 264 3 0 -1418326503 4020 1404 272 45 264 3 0 -1418333069 4023 1404 272 45 264 3 0 diff --git a/html/lines_of_code_by_author.plot b/html/lines_of_code_by_author.plot deleted file mode 100644 index f901fcf..0000000 --- a/html/lines_of_code_by_author.plot +++ /dev/null @@ -1,15 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set terminal png transparent size 640,480 -set output 'lines_of_code_by_author.png' -set key left top -set yrange [0:] -set xdata time -set timefmt "%s" -set format x "%Y-%m-%d" -set grid y -set ylabel "Lines" -set xtics rotate -set bmargin 6 -plot 'lines_of_code_by_author.dat' using 1:2 title "Eric Dill" w lines, 'lines_of_code_by_author.dat' using 1:3 title "Gabriel Iltis" w lines, 'lines_of_code_by_author.dat' using 1:4 title "Thomas A Caswell" w lines, 'lines_of_code_by_author.dat' using 1:5 title "Sameera Abeykoon" w lines, 'lines_of_code_by_author.dat' using 1:6 title "licode" w lines, 'lines_of_code_by_author.dat' using 1:7 title "Wei Xu" w lines, 'lines_of_code_by_author.dat' using 1:8 title "Li Li" w lines diff --git a/html/lines_of_code_by_author.png b/html/lines_of_code_by_author.png deleted file mode 100644 index 847cb4e62c7b19b689ea24ce1f1f505adf672037..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6304 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 diff --git a/html/month_of_year.dat b/html/month_of_year.dat deleted file mode 100644 index 06131f1..0000000 --- a/html/month_of_year.dat +++ /dev/null @@ -1,12 +0,0 @@ -1 0 -2 0 -3 0 -4 0 -5 0 -6 0 -7 0 -8 0 -9 65 -10 52 -11 25 -12 11 diff --git a/html/month_of_year.plot b/html/month_of_year.plot deleted file mode 100644 index 7e4bc7d..0000000 --- a/html/month_of_year.plot +++ /dev/null @@ -1,11 +0,0 @@ -set terminal png transparent size 640,240 -set size 1.0,1.0 - -set output 'month_of_year.png' -unset key -set xrange [0.5:12.5] -set yrange [0:] -set xtics 1 -set grid y -set ylabel "Commits" -plot 'month_of_year.dat' using 1:2:(0.5) w boxes fs solid diff --git a/html/month_of_year.png b/html/month_of_year.png deleted file mode 100644 index e2be75991f4f9f888accaed30c5ef63d4252cfe3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2703 zcmb_ddpK0<8eeP7XpHNG%2a01W%i&nDk_aNb3{65FuJKsr8K3CQd_yqXDAg)CyCk0 zs7R^dbTQ<%97zd@ibAHnLnX7P!Y*W;HP!Q+z0dP>{yOXSz3=zE-}hdB?>fr&@i3&& zC=di0dMvv1)m7qXyG7D$ijUieUglQA{qz0WsKguYI>93q#qmsd$47Y1^`UL$IMPaO^+}Lzp=!o zeh6xWAYfr3hM*(}!saBcwobB!FbNcla}d@B6{^)(akaWjs=_c$faY3zZ>l;~!)D{| z^z`&JG&G{)~vdFFq({p+sb z(>}t`BjtxhP7)40v1Q~qogg(V>`-3@j;Nk5DQgy1C!%Xy{Q2Xlst%*9y0vB>hkm7$ zyohV_)kI7o*{E!c#zNtk*4ZgRRZVrBXY?pmib)-hMmCLySkmB^2@&fUj4S|z6oT|8 zGC7aI$dLYr5ndi!TsLy_I74`uAzwSo#H88IluX{9u16%!e?TMoaULA#y!}O9 z7gJ4jtPWwBi8sp7jRtP0LB20iO8Wc0jDmWy_s7wnYdmBp^x?hEw_NGrwl)TVo2HBa z3;rhk_WR5dx-7MxtUc`Y;qX$O69V^pQVJ;Z z-!+A06O0@psAG_C#O>Wt5N|6nie=_-=D#gYXdy;ilTf|;If=2Edgu8v;1_v);Frr4 zOHJK!=EG+Yr?R;&JoKg+Q{|j67Ece6GSgU@#jba&8z>5a6-mXpe=t%M74 zJq|JJkG<{Ah_z>&rsgM$$H@7~a&q*7lcq7~G^Tf~)Xl+P z0}%hc2Jq$D%?aOj-g8ma;CwGkcNY=Z#-AKkn5G^;6MeHleJ#2BYv361sfoTaAVWnR zCz|d?M6EF8&m+G{cW?2u7cI;SK|}czZ9iuSH4 zw|&&#)#*_k>ZQa3&{vZ^``t$n>h%z`5ThGytL*(=>>7RaEMxad5n;zD_-3fk@rrx( zJT}+hn5kyb_k^0w61skNy`4Qb$sN6!Hd8)z6?`c>%#f>PgiaOXd$KkjKc{Eyn+`^= zTF$kNrfk)7&K?^$=VfxVgP3f)vk2S-#yNKIA48wEjMli3Gcv9dJInXF9E-vw+am^E z)0~W2`Bd(K%18$7 z8J20TGd>mT^o38#-a<8jsSdU<>{IeLw3Wj^Sa^qqF8+FxO+eU9ESo?5sAhyn%5o0> zB-|gh_?fBZxNnr@SqV@?Hw-*K(9B6SI5@vsxwqil>oYf+iB&OAUIkq3rKsmwt#;5G z?J!&raVju2eQ^PAGs$WD!wZIyC^JMQwLD5+eKP2^Km2ik|#$eR`tBEk6Vxu?SJ{xf=FDxU`?%7ULj-? z&cq+es^sjaJ?W!fzr&N9=^T&qd&+>nIQ0iqhi!C>pmw}gsDkDhPZsYI2=agTec-)9 zVp-GjrDb@|%!L+AAOzI{IR*KS@ul1^lf&@ zc<-w~WM9||<4m31)jv}*x>-Fy|M%NPPXoI=*Xb=PQD1F4d2wXw+c2M(ftFcs+f-_f z@U^)Y7XUbBMDsp<*k#Nx;MtYWbmjG1p}fkVR4^Wrb858ES5uewb~ZuxMEyh)2jeLY z*;LMN5gznr`|yf!yFs0Ia_*5a+V)=f7iFQW{KzgI(V$c+BFnx=Nc{@G$&33GyWuhr zV#hVM4HG)&S?crNpC JQ}Be+e*-A&j4l8G diff --git a/html/sortable.js b/html/sortable.js deleted file mode 100644 index 8947732..0000000 --- a/html/sortable.js +++ /dev/null @@ -1,324 +0,0 @@ -/* -Table sorting script by Joost de Valk, check it out at http://www.joostdevalk.nl/code/sortable-table/. -Based on a script from http://www.kryogenix.org/code/browser/sorttable/. -Distributed under the MIT license: http://www.kryogenix.org/code/browser/licence.html . - -Copyright (c) 1997-2007 Stuart Langridge, Joost de Valk. - -Version 1.5.7 -*/ - -/* You can change these values */ -var image_path = ""; -var image_up = "arrow-up.gif"; -var image_down = "arrow-down.gif"; -var image_none = "arrow-none.gif"; -var europeandate = true; -var alternate_row_colors = true; - -/* Don't change anything below this unless you know what you're doing */ -addEvent(window, "load", sortables_init); - -var SORT_COLUMN_INDEX; -var thead = false; - -function sortables_init() { - // Find all tables with class sortable and make them sortable - if (!document.getElementsByTagName) return; - tbls = document.getElementsByTagName("table"); - for (ti=0;ti 0) { - if (t.tHead && t.tHead.rows.length > 0) { - var firstRow = t.tHead.rows[t.tHead.rows.length-1]; - thead = true; - } else { - var firstRow = t.rows[0]; - } - } - if (!firstRow) return; - - // We have a first row: assume it's the header, and make its contents clickable links - for (var i=0;i'+txt+'  ↓'; - } - } - if (alternate_row_colors) { - alternate(t); - } -} - -function ts_getInnerText(el) { - if (typeof el == "string") return el; - if (typeof el == "undefined") { return el }; - if (el.innerText) return el.innerText; //Not needed but it is faster - var str = ""; - - var cs = el.childNodes; - var l = cs.length; - for (var i = 0; i < l; i++) { - switch (cs[i].nodeType) { - case 1: //ELEMENT_NODE - str += ts_getInnerText(cs[i]); - break; - case 3: //TEXT_NODE - str += cs[i].nodeValue; - break; - } - } - return str; -} - -function ts_resortTable(lnk, clid) { - var span; - for (var ci=0;ci'; - newRows.reverse(); - span.setAttribute('sortdir','up'); - } else { - ARROW = '  ↑'; - span.setAttribute('sortdir','down'); - } - // We appendChild rows that already exist to the tbody, so it moves them rather than creating new ones - // don't do sortbottom rows - for (i=0; i'; - } - } - } - span.innerHTML = ARROW; - alternate(t); -} - -function getParent(el, pTagName) { - if (el == null) { - return null; - } else if (el.nodeType == 1 && el.tagName.toLowerCase() == pTagName.toLowerCase()) { - return el; - } else { - return getParent(el.parentNode, pTagName); - } -} - -function sort_date(date) { - // y2k notes: two digit years less than 50 are treated as 20XX, greater than 50 are treated as 19XX - dt = "00000000"; - if (date.length == 11) { - mtstr = date.substr(3,3); - mtstr = mtstr.toLowerCase(); - switch(mtstr) { - case "jan": var mt = "01"; break; - case "feb": var mt = "02"; break; - case "mar": var mt = "03"; break; - case "apr": var mt = "04"; break; - case "may": var mt = "05"; break; - case "jun": var mt = "06"; break; - case "jul": var mt = "07"; break; - case "aug": var mt = "08"; break; - case "sep": var mt = "09"; break; - case "oct": var mt = "10"; break; - case "nov": var mt = "11"; break; - case "dec": var mt = "12"; break; - // default: var mt = "00"; - } - dt = date.substr(7,4)+mt+date.substr(0,2); - return dt; - } else if (date.length == 10) { - if (europeandate == false) { - dt = date.substr(6,4)+date.substr(0,2)+date.substr(3,2); - return dt; - } else { - dt = date.substr(6,4)+date.substr(3,2)+date.substr(0,2); - return dt; - } - } else if (date.length == 8) { - yr = date.substr(6,2); - if (parseInt(yr) < 50) { - yr = '20'+yr; - } else { - yr = '19'+yr; - } - if (europeandate == true) { - dt = yr+date.substr(3,2)+date.substr(0,2); - return dt; - } else { - dt = yr+date.substr(0,2)+date.substr(3,2); - return dt; - } - } - return dt; -} - -function ts_sort_date(a,b) { - dt1 = sort_date(ts_getInnerText(a.cells[SORT_COLUMN_INDEX])); - dt2 = sort_date(ts_getInnerText(b.cells[SORT_COLUMN_INDEX])); - - if (dt1==dt2) { - return 0; - } - if (dt1 - - - - GitStats - VTTools - - - - - -

Tags

-
- -
-
Total tags
1
Average commits per tag
153.00
NameDateCommitsAuthors
0.0.02014-12-07143Eric Dill (58), Gabriel Iltis (41), Thomas A Caswell (23), Sameera Abeykoon (10), licode (7), Wei Xu (2), Li Li (2)
\ No newline at end of file From 4007ce20ef68d039ada1ceeda3d6bb341b0b02b7 Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 23 Jun 2015 04:19:32 -0400 Subject: [PATCH 31/33] DOC: Updated and corrected doc for arith-expr referencing lmfit.asteval As Eric mentioned, lmfit.asteval may be a cleaner and more effective parsing tool for evaluating the input expressions. Added an explicit TODO noting the parser comparision should be completed on next iteration. --- vttools/to_wrap/image_processing/arithmetic.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vttools/to_wrap/image_processing/arithmetic.py b/vttools/to_wrap/image_processing/arithmetic.py index 7caa15d..8d75f39 100644 --- a/vttools/to_wrap/image_processing/arithmetic.py +++ b/vttools/to_wrap/image_processing/arithmetic.py @@ -118,9 +118,9 @@ def arithmetic_expression(expression, A, B, C=None, D=None, E=None, F=None, G=None, H=None): """Custom expression evaluator for up to 8 inputs A-H - Note that it would probably be a good idea (at some point!) to make use of - the 'Interpreter' object in lmfit.asteval as it appears to be a rather - parsing tool. @danielballan can speak to this better than I can + TODO: Note that using the 'Interpreter' object in lmfit.asteval may be a + cleaner and more effective parsing tool for evaluating the input + expression. Parameters ---------- From f67a3bbb920d80d2f8f0eb0ed582a00424ac472a Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Tue, 23 Jun 2015 05:05:25 -0400 Subject: [PATCH 32/33] DOC: Added TODO that docs for logical func need to be updated after sphinx docs --- vttools/to_wrap/image_processing/arithmetic.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/vttools/to_wrap/image_processing/arithmetic.py b/vttools/to_wrap/image_processing/arithmetic.py index 8d75f39..42eacb2 100644 --- a/vttools/to_wrap/image_processing/arithmetic.py +++ b/vttools/to_wrap/image_processing/arithmetic.py @@ -223,11 +223,13 @@ def logical(operation, x1, x2=None, out=None): -------- - User guide section on "Image Operations" ('/doc/resource/user-guide/image.rst') + ** TODO: This needs to be updated when there are sphinx docs for + these tools.** - numpy functions: 'np.logical_and', 'np.logical_or', 'np.logical_not', and 'np.logical_xor' - skxray functions: 'skxray.image_processing.arithmetic.logical_nand', - 'skxray.image_processing.arithmetic.logical_nor', and - 'skxray.image_processing.arithmetic.logical_sub' + 'skxray.image_processing.arithmetic.logical_nor', + and 'skxray.image_processing.arithmetic.logical_sub' Example ------- From 0c1ad48b161c94c83860a2c2bb7815ad41ed3eee Mon Sep 17 00:00:00 2001 From: Gabriel Iltis Date: Wed, 24 Jun 2015 10:26:26 -0400 Subject: [PATCH 33/33] DEV: Added image processing API tools to init.py for VisTrails access --- vt_config/NSLS-II/init.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/vt_config/NSLS-II/init.py b/vt_config/NSLS-II/init.py index b1efcd2..c9b4f88 100644 --- a/vt_config/NSLS-II/init.py +++ b/vt_config/NSLS-II/init.py @@ -115,6 +115,11 @@ def get_modules(): 'skxray.api.diffraction', 'vttools.to_wrap.image_processing.arithmetic', 'vttools.to_wrap.fitting', + 'skxray.api.image_processing.arithmetic.basic_math', + 'skxray.api.image_processing.arithmetic.logic', + 'skxray.api.image_processing.filtering', + 'skxray.api.image_processing.morphology', + 'skxray.api.image_processing.registration' ] for mod_name in mod_targets: