AlphaFrequency.tar

AlphaFrequency/0000755000076500000240000000000013424703035014736 5ustar  lorensenstaff00000000000000AlphaFrequency/CMakeLists.txt0000644000076500000240000000166513424703035017506 0ustar  lorensenstaff00000000000000
cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

project(AlphaFrequency)

find_package(VTK COMPONENTS 
  vtkCommonColor
  vtkFiltersModeling
  vtkInteractionStyle
  vtkRenderingContextOpenGL2
  vtkRenderingCore
  vtkRenderingFreeType
  vtkRenderingGL2PSOpenGL2
  vtkRenderingOpenGL2 QUIET)
if (NOT VTK_FOUND)
  message("Skipping AlphaFrequency: ${VTK_NOT_FOUND_MESSAGE}")
  return ()
endif()
message (STATUS "VTK_VERSION: ${VTK_VERSION}")
if (VTK_VERSION VERSION_LESS "8.90.0")
  # old system
  include(${VTK_USE_FILE})
  add_executable(AlphaFrequency MACOSX_BUNDLE AlphaFrequency.cxx )
  target_link_libraries(AlphaFrequency PRIVATE ${VTK_LIBRARIES})
else ()
  # include all components
  add_executable(AlphaFrequency MACOSX_BUNDLE AlphaFrequency.cxx )
  target_link_libraries(AlphaFrequency PRIVATE ${VTK_LIBRARIES})
  # vtk_module_autoinit is needed
  vtk_module_autoinit(
    TARGETS AlphaFrequency
    MODULES ${VTK_LIBRARIES}
    )
endif () 
AlphaFrequency/AlphaFrequency.py0000755000076500000240000000530413424703035020224 0ustar  lorensenstaff00000000000000#!/usr/bin/env python

import re
from collections import Counter

import vtk


def main():
    fileName = get_program_parameters()

    colors = vtk.vtkNamedColors()

    # Here we read the file keeping only the alpha characters
    #  and calculate the frequency of each letter.
    with open(fileName) as f:
        freq = Counter()
        for x in f:
            remove_digits = re.sub("[\d_]", "", x.strip().lower())
            freq += Counter(re.findall("\w", remove_digits, re.UNICODE))
    maxFreq = max(list(freq.values()))
    keys = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ".lower())

    #
    # graphics stuff
    #
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
    #
    # Setup letters
    #
    letters = list()
    extrude = list()
    mappers = list()
    actors = list()
    i = 0
    for k in keys:
        letters.append(vtk.vtkVectorText())
        letters[i].SetText(k.upper())

        extrude.append(vtk.vtkLinearExtrusionFilter())
        extrude[i].SetInputConnection(letters[i].GetOutputPort())
        extrude[i].SetExtrusionTypeToVectorExtrusion()
        extrude[i].SetVector(0, 0, 1.0)
        extrude[i].SetScaleFactor(float(freq[k]) / maxFreq * 2.50)

        mappers.append(vtk.vtkPolyDataMapper())
        mappers[i].SetInputConnection(extrude[i].GetOutputPort())
        mappers[i].ScalarVisibilityOff()

        actors.append(vtk.vtkActor())
        actors[i].SetMapper(mappers[i])
        actors[i].GetProperty().SetColor(colors.GetColor3d("Peacock"))

        if freq[k] <= 0:
            actors[i].VisibilityOff()
        ren.AddActor(actors[i])
        i += 1

    # Position the actors.
    y = 0.0
    for j in range(0, 2):
        x = 0.0
        for i in range(0, 13):
            actors[j * 13 + i].SetPosition(x, y, 0.0)
            x += 1.5
        y += -3.0

    ren.ResetCamera()
    ren.SetBackground(colors.GetColor3d("Silver"))
    ren.GetActiveCamera().Elevation(30.0)
    ren.GetActiveCamera().Azimuth(-30.0)
    ren.GetActiveCamera().Dolly(1.25)
    ren.ResetCameraClippingRange()

    renWin.SetSize(640, 480)

    # Interact with the data.
    iren.Start()


def get_program_parameters():
    import argparse
    description = 'Linearly extruded fonts to show letter frequency in text.'
    epilogue = '''
    Any file containing text can be used. 
    '''
    parser = argparse.ArgumentParser(description=description, epilog=epilogue,
                                     formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument('filename', help='Gettysburg.txt.')
    args = parser.parse_args()
    return args.filename


if __name__ == '__main__':
    main()
AlphaFrequency/build/0000755000076500000240000000000013424703035016035 5ustar  lorensenstaff00000000000000AlphaFrequency/AlphaFrequency.cxx0000644000076500000240000000654113424703035020377 0ustar  lorensenstaff00000000000000//
// Create bar charts of frequency of letters. 
//
#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkLinearExtrusionFilter.h>
#include <vtkNamedColors.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkVectorText.h>

#include <vector>

int main( int argc, char *argv[] ) 
{
  vtkSmartPointer<vtkNamedColors> colors =
    vtkSmartPointer<vtkNamedColors>::New();

  std::vector<vtkSmartPointer<vtkVectorText> > letters;
  std::vector<vtkSmartPointer<vtkLinearExtrusionFilter> > extrude;
  std::vector<vtkSmartPointer<vtkPolyDataMapper> > mappers;
  std::vector<vtkSmartPointer<vtkActor> > actors;

  char filename[512];
  char text[2];
  static char alphabet[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  int i, j, freq[26], maxFreq;
  float x, y;
  FILE *fPtr;
  int c;

//
// count the letters
//
  if ( (argc == 1) || ((argc == 2) && !(strcmp("-S", argv[1]))) )
    {
    cerr << "Please provide filename: " << argv[0] << " filename\n";
    strcpy( filename, "./Makefile" );
    cerr << "Using the file " << filename << " as input\n";
    }
  else
    {
    strcpy( filename, argv[1] );
    }

  if ( (fPtr = fopen (filename, "r")) == NULL )
    {
    cerr << "Cannot open file: " <<  filename << "\n";
    exit(1);
    }

  for (i=0; i<26; i++) freq[i] = 0;
  while ( (c=fgetc(fPtr)) != EOF )
    {
    if ( isalpha(c) )
      {
      c = tolower(c);
      freq[c-97]++;
      }
    }

  for (maxFreq=0, i=0; i<26; i++)
    if ( freq[i] > maxFreq ) 
      maxFreq = freq[i];
//
// graphics stuff
//
  vtkSmartPointer<vtkRenderer> ren =
    vtkSmartPointer<vtkRenderer>::New();
  vtkSmartPointer<vtkRenderWindow> renWin =
    vtkSmartPointer<vtkRenderWindow>::New();
  renWin->AddRenderer(ren);
  vtkSmartPointer<vtkRenderWindowInteractor> iren =
    vtkSmartPointer<vtkRenderWindowInteractor>::New();
    iren->SetRenderWindow(renWin);
//
// Setup letters
//
  text[1] = '\0';
  for (i=0; i<26; i++)
    {
    text[0] = alphabet[i];
    letters.push_back(vtkSmartPointer<vtkVectorText>::New());
    letters[i]->SetText(text);

    extrude.push_back(vtkSmartPointer<vtkLinearExtrusionFilter>::New());
    extrude[i]->SetInputConnection(letters[i]->GetOutputPort());
    extrude[i]->SetExtrusionType(VTK_VECTOR_EXTRUSION);
    extrude[i]->SetVector(0,0,1.0);
    extrude[i]->SetScaleFactor((double)freq[i] / maxFreq * 2.50);

    mappers.push_back(vtkSmartPointer<vtkPolyDataMapper>::New());
    mappers[i]->SetInputConnection(extrude[i]->GetOutputPort());
    mappers[i]->ScalarVisibilityOff();

    actors.push_back(vtkSmartPointer<vtkActor>::New());
    actors[i]->SetMapper(mappers[i]);
    actors[i]->GetProperty()->SetColor(colors->GetColor3d("Peacock").GetData());
    if ( freq[i] <= 0 )
    {
      actors[i]->VisibilityOff();
    }
    ren->AddActor(actors[i]);
    }
//
// Position actors
//
  for (y=0.0, j=0; j<2; j++, y+=(-3.0))
  {
    for (x=0.0, i=0; i<13; i++, x+=1.5)
    {
      actors[j*13 + i]->SetPosition(x, y, 0.0);
    }
  }

  ren->ResetCamera();
  ren->SetBackground(colors->GetColor3d("Silver").GetData());
  ren->GetActiveCamera()->Elevation(30.0);
  ren->GetActiveCamera()->Azimuth(-30.0);
  ren->GetActiveCamera()->Dolly(1.25);
  ren->ResetCameraClippingRange();

  renWin->SetSize(640, 480);

  // interact with data
  renWin->Render();
  iren->Start();

  return EXIT_SUCCESS;
}